@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/custom-variables-lifecycle.integration.test.ts

@@ -0,0 +1,365 @@
+import { type EventBus, SessionManager, type Theme } from "@earendil-works/pi-coding-agent";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const runtime = vi.hoisted(() => ({
+	config: undefined as import("../extensions/zentui/config").PolishedTuiConfig | undefined,
+	hooks: undefined as Record<string, (...args: never[]) => unknown> | undefined,
+}));
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return {
+		...actual,
+		loadConfig() {
+			return runtime.config;
+		},
+		saveEditorComponentPatch(patch: object) {
+			Object.assign(runtime.config?.components.editor ?? {}, patch);
+			return runtime.config;
+		},
+		saveFooterComponentPatch(patch: object) {
+			Object.assign(runtime.config?.components.footer ?? {}, patch);
+			return runtime.config;
+		},
+		savePolishedEditorStylePatch(patch: object) {
+			Object.assign(runtime.config?.components.editor.styles.opencode ?? {}, patch);
+			return runtime.config;
+		},
+		saveMinimalistEditorStylePatch(patch: object) {
+			Object.assign(runtime.config?.components.editor.styles.minimalist ?? {}, patch);
+			return runtime.config;
+		},
+	};
+});
+vi.mock("../extensions/zentui/settings-command", () => ({
+	registerZentuiSettingsCommand(_pi: unknown, hooks: typeof runtime.hooks) {
+		runtime.hooks = hooks;
+	},
+}));
+
+import { mergeConfig } from "../extensions/zentui/config";
+import {
+	ZENTUI_VARIABLE_CAPABILITY_EVENT,
+	ZENTUI_VARIABLE_EVENT,
+} from "../extensions/zentui/custom-variables";
+import zentui from "../extensions/zentui/index";
+import { createOmpUiAdapter } from "../extensions/zentui/omp-ui";
+
+type Editor = {
+	render(width: number): string[];
+	getText(): string;
+	setText(text: string): void;
+	getExpandedText(): string;
+};
+type Factory = (...args: never[]) => Editor;
+type Handler = (event: unknown, ctx: unknown) => unknown;
+function harness(mode = "tui", omp = false) {
+	const handlers = new Map<string, Handler[]>();
+	const listeners = new Map<string, Set<(value: unknown) => void>>();
+	const events: EventBus = {
+		emit(name, value) {
+			for (const listener of listeners.get(name) ?? []) listener(value);
+		},
+		on(name, listener) {
+			const list = listeners.get(name) ?? new Set();
+			list.add(listener);
+			listeners.set(name, list);
+			return () => list.delete(listener);
+		},
+	};
+	let factory: Factory | undefined;
+	let editor: Editor | undefined;
+	let footer: { render(width: number): string[]; dispose?(): void } | undefined;
+	let text = "retained draft";
+	const requestRender = vi.fn();
+	const theme = {
+		fg: (_color: string, value: string) => value,
+		bold: (value: string) => value,
+		italic: (value: string) => value,
+		getThinkingBorderColor: () => (value: string) => value,
+	} as unknown as Theme;
+	const ui = {
+		theme,
+		getEditorComponent: () => factory,
+		setEditorComponent(value?: Factory) {
+			// The real public Pi setter transfers the current editor text to its replacement.
+			const draft = editor?.getText() ?? text;
+			factory = value;
+			editor = value?.(
+				{ requestRender, terminal: { rows: 40, columns: 140 } } as never,
+				{
+					borderColor: (value: string) => value,
+					selectList: {
+						selectedPrefix: (value: string) => value,
+						selectedText: (value: string) => value,
+						description: (value: string) => value,
+						scrollInfo: (value: string) => value,
+						noMatch: (value: string) => value,
+					},
+				} as never,
+				{} as never,
+			);
+			editor?.setText(draft);
+			text = draft;
+		},
+		getEditorText: () => editor?.getText() ?? text,
+		getExpandedEditorText: () => editor?.getExpandedText() ?? text,
+		setEditorText(value: string) {
+			text = value;
+			editor?.setText(value);
+		},
+		setFooter(value?: (...args: never[]) => NonNullable<typeof footer>) {
+			footer?.dispose?.();
+			footer = value?.(
+				{ requestRender } as never,
+				theme as never,
+				{ getExtensionStatuses: () => new Map(), onBranchChange: () => () => {} } as never,
+			);
+		},
+		setStatus: vi.fn(),
+	};
+	const adapter = omp ? createOmpUiAdapter(ui as never) : undefined;
+	const ctx = {
+		mode,
+		hasUI: mode === "tui",
+		cwd: "/tmp/zentui-variable-test",
+		ui: adapter?.ui ?? ui,
+		sessionManager: SessionManager.inMemory("/tmp/zentui-variable-test"),
+		model: { id: "test-model", provider: "test", contextWindow: 100_000 },
+		getContextUsage: () => ({ tokens: 1000, contextWindow: 100_000, percent: 1 }),
+		isIdle: () => true,
+	};
+	zentui({
+		events,
+		registerCommand() {},
+		registerEntryRenderer() {},
+		on(name: string, handler: Handler) {
+			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+		},
+		getThinkingLevel: () => "off",
+	} as never);
+	return {
+		ctx,
+		ui,
+		events,
+		requestRender,
+		render: (width = 140) => editor?.render(width).join("\n") ?? "",
+		editorText: () => editor?.getText() ?? text,
+		renderFooter: () => footer?.render(100).join("\n") ?? "",
+		async emit(name: string) {
+			for (const handler of handlers.get(name) ?? []) await handler({}, ctx);
+			if (name === "session_shutdown") adapter?.dispose();
+		},
+		capability(key = "@scope/usage:quota") {
+			const probe = { supported: false, active: false, key };
+			events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, probe);
+			return probe;
+		},
+		publish(value?: string) {
+			events.emit(ZENTUI_VARIABLE_EVENT, { key: "@scope/usage:quota", text: value });
+		},
+		hook(name: string, patch: object) {
+			runtime.hooks?.[name]?.(patch as never, ctx as never);
+		},
+	};
+}
+
+beforeEach(() => {
+	vi.useFakeTimers();
+	runtime.config = mergeConfig({
+		projectRefreshIntervalMs: 0,
+		components: {
+			editor: {
+				style: "minimalist",
+				styles: {
+					minimalist: {
+						formats: {
+							topLeft: "",
+							topMiddle: "$quota",
+							topRight: "",
+							bottomLeft: "",
+							bottomMiddle: "",
+							bottomRight: "",
+						},
+						variables: { quota: "@scope/usage:quota" },
+					},
+				},
+			},
+			footer: { style: "native" },
+			userMessages: { enabled: false },
+			selectorBorders: { enabled: false },
+			workingLine: { enabled: false },
+		},
+	});
+});
+afterEach(() => {
+	vi.useRealTimers();
+	runtime.hooks = undefined;
+});
+
+describe("custom variable editor lifecycle", () => {
+	it("gates on actual owned decoration, updates idle slots, preserves the draft, and clears on shutdown", async () => {
+		const h = harness();
+		expect(h.capability()).toMatchObject({ supported: true, active: false });
+		await h.emit("session_start");
+		h.render();
+		expect(h.capability()).toMatchObject({ active: true });
+		expect(h.capability("@other/unused:value").active).toBe(false);
+		h.publish("CC $459/1200");
+		expect(h.render()).toContain("CC $459/1200");
+		expect(h.requestRender).toHaveBeenCalled();
+		expect(h.editorText()).toBe("retained draft");
+		await h.emit("session_shutdown");
+		expect(h.capability().active).toBe(false);
+	});
+	it("keeps idle custom-variable demand after OMP constructs the editor synchronously", async () => {
+		const h = harness("tui", true);
+		try {
+			await h.emit("session_start");
+			h.render();
+			h.publish("OMP quota $459/1200");
+			expect(h.render()).toContain("OMP quota $459/1200");
+			expect(h.editorText()).toBe("retained draft");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it("discards values on disable and requires republishing after re-enable", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		h.render();
+		h.publish("old quota");
+		h.hook("setEditorComponent", { enabled: false });
+		expect(h.capability().active).toBe(false);
+		h.hook("setEditorComponent", { enabled: true });
+		h.render();
+		expect(h.capability().active).toBe(true);
+		expect(h.render()).not.toContain("old quota");
+		h.publish("new quota");
+		expect(h.render()).toContain("new quota");
+		await h.emit("session_shutdown");
+	});
+	it("clears on a new session and releases demand when templates no longer reference the key", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		h.render();
+		h.publish("old quota");
+		await h.emit("session_start");
+		expect(h.render()).not.toContain("old quota");
+		h.publish("new quota");
+		h.hook("setMinimalist", {
+			formats: {
+				topLeft: "",
+				topMiddle: "",
+				topRight: "",
+				bottomLeft: "",
+				bottomMiddle: "",
+				bottomRight: "",
+			},
+		});
+		expect(h.capability().active).toBe(false);
+		expect(h.render()).not.toContain("new quota");
+		await h.emit("session_shutdown");
+	});
+	it("fails open after editor ownership is displaced and remains inactive outside TUI", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		h.render();
+		h.publish("old quota");
+		h.ui.setEditorComponent(undefined);
+		expect(h.capability().active).toBe(false);
+		await h.emit("model_select");
+		expect(h.capability().active).toBe(false);
+		await h.emit("session_shutdown");
+		const headless = harness("json");
+		await headless.emit("session_start");
+		expect(headless.capability().active).toBe(false);
+		await headless.emit("session_shutdown");
+	});
+});
+
+it.each(["opencode", "opencode-copy-friendly"] as const)(
+	"activates %s only after safe rendering and drops stale values on a style transition",
+	async (style) => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.style = style;
+		runtime.config.components.editor.styles[style].metadataFormat = "$quota";
+		runtime.config.components.editor.styles[style].variables = { quota: "@scope/usage:quota" };
+		const h = harness();
+		await h.emit("session_start");
+		expect(h.capability().active).toBe(false);
+		h.render();
+		expect(h.capability().active).toBe(true);
+		h.publish("quota first");
+		expect(h.render()).toContain("quota first");
+		h.hook("setEditorComponent", { style: "accent-rail" });
+		expect(h.capability().active).toBe(false);
+		h.render();
+		h.hook("setEditorComponent", { style });
+		h.render();
+		expect(h.render()).not.toContain("quota first");
+		h.publish("quota second");
+		expect(h.render()).toContain("quota second");
+		await h.emit("session_shutdown");
+	},
+);
+
+it.each([false, true])(
+	"reconciles external Footer disposal before reinstall with Editor enabled=%s",
+	async (editorEnabled) => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.enabled = editorEnabled;
+		runtime.config.components.footer.style = "starship";
+		Object.assign(runtime.config.components.footer.styles.starship, {
+			format: "$quota",
+			variables: { quota: "@scope/usage:quota" },
+			responsive: false,
+		});
+		const h = harness();
+		await h.emit("session_start");
+		h.render();
+		h.publish("old quota");
+		expect(h.renderFooter()).toContain("old quota");
+
+		// Another extension disposes Footer; reinstall before any event or timer refresh.
+		h.ui.setFooter(undefined);
+		h.hook("setFooterComponent", { style: "starship" });
+		if (editorEnabled) {
+			expect(h.render()).toContain("old quota");
+			expect(h.renderFooter()).toContain("old quota");
+		} else {
+			expect(h.renderFooter()).not.toContain("old quota");
+		}
+		expect(h.capability().active).toBe(true);
+		h.publish("new quota");
+		expect(h.renderFooter()).toContain("new quota");
+		await h.emit("session_shutdown");
+	},
+);
+
+it("retains a shared value while Footer still consumes it after Editor disable, then clears after both release", async () => {
+	if (!runtime.config) throw new Error("missing config");
+	Object.assign(runtime.config.components.footer.styles.starship, {
+		format: "$quota",
+		variables: { quota: "@scope/usage:quota" },
+		responsive: false,
+	});
+	const h = harness();
+	await h.emit("session_start");
+	h.render();
+	h.hook("setFooterComponent", { style: "starship" });
+	h.publish("shared quota");
+	expect(h.renderFooter()).toContain("shared quota");
+	h.hook("setEditorComponent", { enabled: false });
+	expect(h.capability().active).toBe(true);
+	expect(h.renderFooter()).toContain("shared quota");
+	h.hook("setEditorComponent", { enabled: true });
+	h.render();
+	expect(h.render()).toContain("shared quota");
+	h.hook("setEditorComponent", { enabled: false });
+	h.hook("setFooterComponent", { style: "native" });
+	expect(h.capability().active).toBe(false);
+	h.hook("setEditorComponent", { enabled: true });
+	h.render();
+	expect(h.render()).not.toContain("shared quota");
+	await h.emit("session_shutdown");
+});

package/dist/extensions/pi-zentui/test/custom-variables.test.ts

@@ -0,0 +1,330 @@
+import type { EventBus } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it, vi } from "vitest";
+import {
+	CustomVariables,
+	MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS,
+	MAX_CUSTOM_VARIABLE_TEXT_CODE_UNITS,
+	MAX_CUSTOM_VARIABLES,
+	sanitizeCustomVariableText,
+	ZENTUI_VARIABLE_CAPABILITY_EVENT,
+	ZENTUI_VARIABLE_EVENT,
+	ZENTUI_VARIABLE_PROTOCOL_VERSION,
+} from "../extensions/zentui/custom-variables";
+
+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);
+		},
+	};
+}
+
+function registry(isActive: (key?: string) => boolean = () => true) {
+	const events = eventBus();
+	const onChange = vi.fn();
+	const variables = new CustomVariables(events, isActive, onChange);
+	return { events, onChange, variables };
+}
+
+function publish(events: EventBus, key: string, text?: string) {
+	events.emit(ZENTUI_VARIABLE_EVENT, { key, text });
+}
+
+describe("custom-variable protocol", () => {
+	it("reports v1 support and any-consumer or per-key demand without requiring a value", () => {
+		let active = false;
+		const isActive = vi.fn((key?: string) => active && (key === undefined || key === "pkg:queue"));
+		const { events, variables, onChange } = registry(isActive);
+		const capability = { supported: false, active: false };
+		events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, capability);
+		expect(capability).toEqual({ supported: true, active: false, version: 1 });
+		expect(isActive).toHaveBeenLastCalledWith(undefined);
+		active = true;
+		events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, capability);
+		expect(capability.active).toBe(true);
+		for (const [key, expected] of [
+			["pkg:queue", true],
+			["pkg:unused", false],
+		] as const) {
+			const keyed = { supported: false, active: false, key };
+			events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, keyed);
+			expect(keyed).toEqual({
+				supported: true,
+				active: expected,
+				key,
+				version: ZENTUI_VARIABLE_PROTOCOL_VERSION,
+			});
+			expect(isActive).toHaveBeenLastCalledWith(key);
+		}
+		expect(variables.snapshot().size).toBe(0);
+		expect(onChange).not.toHaveBeenCalled();
+	});
+
+	it("ignores malformed, immutable, or hostile capability probes without running accessors", () => {
+		const isActive = vi.fn(() => true);
+		const { events } = registry(isActive);
+		const getter = vi.fn(() => "pkg:queue");
+		const accessor = Object.defineProperty({}, "key", { get: getter });
+		const hostile = new Proxy(
+			{},
+			{
+				getOwnPropertyDescriptor: () => {
+					throw new Error("bad");
+				},
+			},
+		);
+		for (const probe of [
+			null,
+			undefined,
+			[],
+			"probe",
+			{},
+			{ key: 1 },
+			{ key: "" },
+			{ key: "x".repeat(MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS + 1) },
+			accessor,
+			hostile,
+			Object.freeze({ supported: false, active: false }),
+		]) {
+			expect(() => events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, probe)).not.toThrow();
+		}
+		expect(getter).not.toHaveBeenCalled();
+		expect(isActive).toHaveBeenCalledTimes(2);
+		const setter = vi.fn();
+		const probe = Object.defineProperty({}, "supported", { set: setter, configurable: true });
+		events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, probe);
+		expect(setter).not.toHaveBeenCalled();
+		expect(probe).toMatchObject({ supported: true, active: true, version: 1 });
+	});
+
+	it("stores raw last-update-wins values in deterministic, locale-independent key order", () => {
+		const { events, variables, onChange } = registry();
+		for (const key of ["z:queue", "a:queue", "A:queue", "@scope/pkg:queue"]) {
+			publish(events, key, key);
+		}
+		const raw = "\x1b[31mqueue\n2\x1b]8;;https://example.com\x07link";
+		publish(events, "a:queue", raw);
+		expect([...variables.snapshot()]).toEqual([
+			["@scope/pkg:queue", "@scope/pkg:queue"],
+			["A:queue", "A:queue"],
+			["a:queue", raw],
+			["z:queue", "z:queue"],
+		]);
+		expect(onChange).toHaveBeenCalledTimes(5);
+		publish(events, "a:queue", raw);
+		expect(onChange).toHaveBeenCalledTimes(5);
+	});
+
+	it("returns detached snapshots that cannot modify registry state", () => {
+		const { events, variables } = registry();
+		publish(events, "pkg:key", "one");
+		const snapshot = variables.snapshot();
+		(snapshot as Map<string, string>).set("pkg:key", "tampered");
+		(snapshot as Map<string, string>).set("other", "tampered");
+		expect([...variables.snapshot()]).toEqual([["pkg:key", "one"]]);
+		publish(events, "pkg:key", "two");
+		expect(snapshot.get("pkg:key")).toBe("tampered");
+	});
+
+	it("ignores inactive positive updates but accepts inactive removals", () => {
+		let active = true;
+		const { events, variables, onChange } = registry((key) => active && key !== "unused");
+		publish(events, "pkg:a", "one");
+		publish(events, "pkg:b", "two");
+		publish(events, "unused", "ignored");
+		active = false;
+		publish(events, "pkg:a", "ignored");
+		publish(events, "new", "ignored");
+		expect(onChange).toHaveBeenCalledTimes(2);
+		publish(events, "pkg:a", "");
+		publish(events, "pkg:b");
+		publish(events, "absent");
+		expect(variables.snapshot().size).toBe(0);
+		expect(onChange).toHaveBeenCalledTimes(4);
+	});
+
+	it("rejects malformed and over-limit updates without executing publisher functions", () => {
+		const { events, variables, onChange } = registry();
+		const callback = vi.fn();
+		const accessor = Object.defineProperty({ key: "pkg:key" }, "text", { get: callback });
+		const hostile = new Proxy(
+			{},
+			{
+				getOwnPropertyDescriptor: () => {
+					throw new Error("bad");
+				},
+			},
+		);
+		for (const update of [
+			null,
+			undefined,
+			[],
+			{},
+			"text",
+			{ key: 1, text: "x" },
+			{ key: "", text: "x" },
+			{ key: "x".repeat(MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS + 1), text: "x" },
+			{ key: "pkg:key", text: null },
+			{ key: "pkg:key", text: 1 },
+			{ key: "pkg:key", text: callback },
+			{ key: "pkg:key", text: "x".repeat(MAX_CUSTOM_VARIABLE_TEXT_CODE_UNITS + 1) },
+			accessor,
+			hostile,
+		]) {
+			expect(() => events.emit(ZENTUI_VARIABLE_EVENT, update)).not.toThrow();
+		}
+		expect(callback).not.toHaveBeenCalled();
+		expect(onChange).not.toHaveBeenCalled();
+		expect(variables.snapshot().size).toBe(0);
+	});
+
+	it("accepts exact UTF-16 bounds and rejects one extra code unit", () => {
+		const { events, variables, onChange } = registry();
+		const key = "😀".repeat(MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS / 2);
+		const text = "😀".repeat(MAX_CUSTOM_VARIABLE_TEXT_CODE_UNITS / 2);
+		publish(events, key, text);
+		publish(events, `${key}x`, text);
+		publish(events, key, `${text}x`);
+		expect([...variables.snapshot()]).toEqual([[key, text]]);
+		expect(onChange).toHaveBeenCalledTimes(1);
+	});
+
+	it("bounds unique keys while permitting updates, removals, and replacement keys at capacity", () => {
+		const { events, variables, onChange } = registry();
+		for (let index = 0; index < MAX_CUSTOM_VARIABLES; index += 1) {
+			publish(events, `pkg:${index}`, `${index}`);
+		}
+		publish(events, "overflow", "ignored");
+		expect(variables.snapshot().size).toBe(MAX_CUSTOM_VARIABLES);
+		expect(onChange).toHaveBeenCalledTimes(MAX_CUSTOM_VARIABLES);
+		publish(events, "pkg:0", "updated");
+		expect(variables.snapshot().get("pkg:0")).toBe("updated");
+		publish(events, "pkg:1");
+		publish(events, "replacement", "accepted");
+		expect(variables.snapshot().size).toBe(MAX_CUSTOM_VARIABLES);
+		expect(variables.snapshot().get("replacement")).toBe("accepted");
+		expect(onChange).toHaveBeenCalledTimes(MAX_CUSTOM_VARIABLES + 3);
+	});
+
+	it("reconciles only inactive keys across independent consumers and notifies once", () => {
+		const editor = new Set(["pkg:shared", "pkg:editor"]);
+		const footer = new Set(["pkg:shared", "pkg:footer"]);
+		const { events, variables, onChange } = registry((key) =>
+			key === undefined ? editor.size + footer.size > 0 : editor.has(key) || footer.has(key),
+		);
+		for (const key of ["pkg:shared", "pkg:editor", "pkg:footer"]) publish(events, key, key);
+		editor.clear();
+		variables.reconcile();
+		expect([...variables.snapshot().keys()]).toEqual(["pkg:footer", "pkg:shared"]);
+		expect(onChange).toHaveBeenCalledTimes(4);
+		variables.reconcile();
+		expect(onChange).toHaveBeenCalledTimes(4);
+		footer.clear();
+		variables.reconcile();
+		expect(variables.snapshot().size).toBe(0);
+		expect(onChange).toHaveBeenCalledTimes(5);
+		editor.add("pkg:editor");
+		expect(variables.snapshot().size).toBe(0);
+		publish(events, "pkg:editor", "fresh");
+		expect([...variables.snapshot()]).toEqual([["pkg:editor", "fresh"]]);
+	});
+
+	it("clears session state once and keeps runtime listeners available for the next session", () => {
+		const { events, variables, onChange } = registry();
+		variables.clear();
+		variables.reconcile();
+		expect(onChange).not.toHaveBeenCalled();
+		publish(events, "pkg:key", "old session");
+		variables.clear();
+		variables.clear();
+		expect(onChange).toHaveBeenCalledTimes(2);
+		expect(variables.snapshot().size).toBe(0);
+		publish(events, "pkg:key", "new session");
+		expect(variables.snapshot().get("pkg:key")).toBe("new session");
+		expect(onChange).toHaveBeenCalledTimes(3);
+	});
+
+	it("does not start resources or notify when no event bus is provided", () => {
+		const isActive = vi.fn(() => true);
+		const onChange = vi.fn();
+		const variables = new CustomVariables(undefined, isActive, onChange);
+		variables.clear();
+		variables.reconcile();
+		expect(variables.snapshot().size).toBe(0);
+		expect(isActive).not.toHaveBeenCalled();
+		expect(onChange).not.toHaveBeenCalled();
+	});
+});
+
+describe("sanitizeCustomVariableText", () => {
+	it("normalizes a single line and strips cursor, title, clipboard, and other terminal controls", () => {
+		const raw =
+			" \x1b]0;title\x07\x1b]52;c;secret\x07\x1b[2J\x1b[4Hqueue\n\t2\r\f\vitems\x00\x7f\x9f ";
+		expect(sanitizeCustomVariableText(raw)).toBe("queue 2 items");
+		expect(sanitizeCustomVariableText(raw, "zentui")).toBe("queue 2 items");
+	});
+
+	it("preserves safe SGR in Original and closes styles before adjacent content", () => {
+		expect(sanitizeCustomVariableText("\x1b[31mqueue 2")).toBe("\x1b[31mqueue 2\x1b[0m");
+		expect(sanitizeCustomVariableText("\x1b[38;2;1;2;3mqueue\x1b[0m")).toBe(
+			"\x1b[38;2;1;2;3mqueue\x1b[0m",
+		);
+		expect(sanitizeCustomVariableText("\x1b[1:2mqueue\x1b[m")).toBe("\x1b[1:2mqueue\x1b[m");
+		expect(sanitizeCustomVariableText("\x1b[0;31mqueue")).toBe("\x1b[0;31mqueue\x1b[0m");
+	});
+
+	it("preserves HTTP(S) OSC8 links, normalizes URLs, and closes unclosed links", () => {
+		for (const protocol of ["http", "https"]) {
+			expect(
+				sanitizeCustomVariableText(`\x1b]8;id=queue;${protocol}://example.com\x1b\\link`),
+			).toBe(`\x1b]8;;${protocol}://example.com/\x07link\x1b]8;;\x07`);
+		}
+		expect(sanitizeCustomVariableText("\x1b[32m\x1b]8;;https://example.com\x07link")).toBe(
+			"\x1b[32m\x1b]8;;https://example.com/\x07link\x1b]8;;\x07\x1b[0m",
+		);
+	});
+
+	it("rejects unsafe or malformed link targets and prevents a preceding link leaking through", () => {
+		for (const url of [
+			"file:///tmp/a",
+			"javascript:alert(1)",
+			"data:text/plain,hi",
+			"not a url",
+			"https://a b",
+		]) {
+			expect(sanitizeCustomVariableText(`\x1b]8;;${url}\x07text`)).toBe("text");
+			expect(
+				sanitizeCustomVariableText(`\x1b]8;;https://example.com\x07a\x1b]8;;${url}\x07b`),
+			).toBe("\x1b]8;;https://example.com/\x07a\x1b]8;;\x07b");
+		}
+	});
+
+	it("strips all publisher styling and links in Zentui mode", () => {
+		const raw = "\x1b[31m\x1b]8;;https://example.com\x07queue\n2\x1b]8;;\x07\x1b[0m";
+		expect(sanitizeCustomVariableText(raw, "zentui")).toBe("queue 2");
+	});
+
+	it("drops invisible control-only values and preserves wide glyphs and graphemes", () => {
+		for (const raw of [
+			"",
+			" \n\t ",
+			"\x1b[31m\x1b[0m",
+			"\x1b]8;;https://example.com\x07\x1b]8;;\x07",
+		]) {
+			expect(sanitizeCustomVariableText(raw)).toBe("");
+		}
+		const visible = "界 e\u0301 👩‍💻";
+		const sanitized = sanitizeCustomVariableText(`\x1b[35m${visible}`);
+		expect(sanitized).toBe(`\x1b[35m${visible}\x1b[0m`);
+		expect(visibleWidth(sanitized)).toBe(visibleWidth(visible));
+		expect(sanitizeCustomVariableText(sanitized, "zentui")).toBe(visible);
+	});
+});