gentle-pi 2.4.0 → 2.6.0

package/tests/session-worktree-registry.test.ts

@@ -0,0 +1,135 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { SessionWorktreeRegistry, resolveSessionWorktree, resolveSessionWorktreeWithGit, SESSION_WORKTREE_ENTRY, toolWorktreePath, worktreeGitEnvironment } from "../lib/session-worktree-registry.ts";
+
+// All Git and session writes belong to unique fixtures, never the live clone.
+function fixture(t: test.TestContext) {
+	const dir = realpathSync(mkdtempSync(join(tmpdir(), "session-worktrees-")));
+	t.after(() => rmSync(dir, { recursive: true, force: true }));
+	const main = join(dir, "main");
+	const linked = join(dir, "linked");
+	const other = join(dir, "other");
+	const empty = join(dir, "empty");
+	mkdirSync(empty);
+	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+	Object.assign(env, { GIT_CONFIG_GLOBAL: join(empty, "config"), GIT_CONFIG_NOSYSTEM: "1", GIT_ATTR_NOSYSTEM: "1" });
+	writeFileSync(join(empty, "config"), "");
+	const git = (cwd: string, args: string[]) => execFileSync("git", ["-C", cwd, "-c", `core.hooksPath=${empty}`, "-c", "commit.gpgsign=false", ...args], { env, stdio: ["ignore", "pipe", "pipe"] });
+	git(dir, ["init", "--initial-branch=main", `--template=${empty}`, main]);
+	git(main, ["-c", "user.name=Test", "-c", "user.email=test@example.invalid", "commit", "--allow-empty", "-m", "Fixture"]);
+	git(main, ["worktree", "add", "-b", "linked", linked]);
+	git(dir, ["init", `--template=${empty}`, other]);
+	mkdirSync(join(linked, "src"));
+	writeFileSync(join(linked, "src", "file.ts"), "preexisting\n");
+	const alias = join(dir, "alias");
+	symlinkSync(linked, alias, "dir");
+	return { dir, main, linked, other, alias };
+}
+
+function host(cwd: string, session = SessionManager.inMemory(cwd)) {
+	const emitted: unknown[] = [];
+	const pi = { appendEntry: (type: string, data: unknown) => { session.appendCustomEntry(type, data); }, events: { emit: (_name: string, data: unknown) => emitted.push(data) } };
+	return { pi, session, emitted, registry: () => new SessionWorktreeRegistry(pi, session, cwd) };
+}
+
+test("canonical roots include cwd, dedupe aliases immediately and reject unrelated clones", (t) => {
+	const f = fixture(t);
+	const h = host(f.main);
+	const registry = h.registry();
+	registry.start();
+	assert.deepEqual(registry.roots(), [f.main]);
+	assert.equal(registry.register(join(f.alias, "src", "file.ts"), "tool:read"), f.linked);
+	registry.register(f.linked, "explicit");
+	assert.deepEqual(registry.roots(), [f.main, f.linked]);
+	assert.equal(h.session.getEntries().length, 2);
+	assert.throws(() => registry.register(f.other, "explicit"), /same Git clone/);
+	assert.throws(() => registry.register(join(f.dir, "missing"), "explicit"), /worktree/);
+	assert.equal(resolveSessionWorktree(f.alias, f.main)?.root, f.linked);
+});
+
+test("restore reads the whole session tree, resumes the same id, and ignores new/fork/clone ids", (t) => {
+	const f = fixture(t);
+	const session = SessionManager.create(f.main, join(f.dir, "sessions"));
+	const first = session.appendMessage({ role: "user", content: "start", timestamp: 1 });
+	// Pi persists entries after the first assistant message.
+	session.appendMessage({ role: "assistant", content: [], api: "openai-responses", provider: "test", model: "test", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "stop", timestamp: 2 });
+	const h = host(f.main, session);
+	h.registry().start();
+	h.registry().register(f.linked, "explicit");
+	session.branch(first);
+	assert.deepEqual(h.registry().roots(), [f.main, f.linked], "off-branch registrations remain session-wide");
+	const resumed = host(f.main, SessionManager.open(session.getSessionFile()!));
+	assert.deepEqual(resumed.registry().roots(), [f.main, f.linked]);
+	const forkPath = session.createBranchedSession(session.getEntries().at(-1)!.id)!;
+	const fork = host(f.main, SessionManager.open(forkPath));
+	fork.registry().start();
+	assert.deepEqual(fork.registry().roots(), [f.main], "inherited custom entries carry the old id");
+	const fresh = host(f.main);
+	for (const entry of resumed.session.getEntries()) {
+		if (entry.type === "custom") fresh.session.appendCustomEntry(entry.customType, entry.data);
+	}
+	fresh.registry().start();
+	assert.deepEqual(fresh.registry().roots(), [f.main], "cloned entries cannot expand a new session registry");
+});
+
+test("durable append works without a shell listener and independent registries do not double append", (t) => {
+	const f = fixture(t);
+	const h = host(f.main);
+	const shell = h.registry();
+	shell.start();
+	const agents = h.registry();
+	agents.register(f.linked, "subagent:spawn");
+	assert.deepEqual(shell.roots(), [f.main, f.linked]);
+	shell.register(f.alias, "explicit");
+	assert.equal(h.session.getEntries().filter((e) => e.type === "custom" && e.customType === SESSION_WORKTREE_ENTRY).length, 2);
+	agents.close();
+	assert.throws(() => agents.register(f.main, "explicit"), /inactive session/);
+});
+
+test("restoration validates entries and hides missing roots without deleting their registrations", (t) => {
+	const f = fixture(t);
+	const h = host(f.main);
+	const registry = h.registry();
+	registry.start();
+	registry.register(f.linked, "explicit");
+	h.session.appendCustomEntry(SESSION_WORKTREE_ENTRY, { sessionId: h.session.getSessionId(), root: f.other, evidence: "explicit" });
+	h.session.appendCustomEntry(SESSION_WORKTREE_ENTRY, { sessionId: h.session.getSessionId(), root: 42 });
+	rmSync(f.linked, { recursive: true });
+	assert.deepEqual(registry.roots(), [f.main]);
+	assert.ok(h.session.getEntries().some((entry) => entry.type === "custom" && (entry.data as { root?: string })?.root === f.linked));
+});
+
+test("Git child environment removes routing and config overrides without mutating its source", () => {
+	const env = { PATH: "/tools", HOME: "/fixture", GIT_DIR: "/foreign/.git", GIT_WORK_TREE: "/foreign", GIT_INDEX_FILE: "/foreign/index", GIT_COMMON_DIR: "/foreign/common", GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: "core.worktree", GIT_CONFIG_VALUE_0: "/foreign", git_dir: "/windows-case-alias" };
+	const before = { ...env };
+	assert.deepEqual(worktreeGitEnvironment(env), { PATH: "/tools", HOME: "/fixture" });
+	assert.deepEqual(env, before);
+});
+
+test("session startup identity lookup hides its direct Git children", (t) => {
+	const f = fixture(t);
+	const calls: Array<{ command: string; args: readonly string[]; options: Record<string, unknown> }> = [];
+	const run = ((command: string, args: readonly string[], options: Record<string, unknown>) => {
+		calls.push({ command, args, options });
+		return args.at(-1) === "--show-toplevel" ? `${f.main}\n` : `${join(f.main, ".git")}\n`;
+	}) as typeof import("node:child_process").execFileSync;
+	assert.equal(resolveSessionWorktreeWithGit(f.main, f.main, run)?.root, f.main);
+	assert.equal(calls.length, 2);
+	for (const call of calls) {
+		assert.equal(call.command, "git");
+		assert.equal(call.options.shell, false);
+		assert.equal(call.options.windowsHide, true);
+	}
+});
+
+test("only standard path-bearing calls have registration candidates; shell and prose never do", () => {
+	for (const name of ["read", "write", "edit", "grep", "find", "ls"]) assert.equal(toolWorktreePath(name, { path: "../linked/file" }), "../linked/file");
+	for (const name of ["grep", "find", "ls"]) assert.equal(toolWorktreePath(name, {}), ".");
+	for (const name of ["bash", "powershell", "custom", "subagent_run"]) assert.equal(toolWorktreePath(name, { path: "/linked", command: "cd /linked", task: "/linked" }), undefined);
+	assert.equal(toolWorktreePath("read", { path: 42 }), undefined);
+});

package/tests/shell-bar.test.ts

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+	formatCost,
+	formatTokens,
+	gaugeTone,
+	renderGauge,
+	renderShellBar,
+	shellEnabled,
+	type ShellBarModel,
+	type ShellBarTheme,
+} from "../lib/shell-bar.ts";
+
+// The Gentle Shell bar replaces pi's three-line footer with one line of
+// segments. Rendering is pure so it can be verified without a TUI.
+
+const taggedTheme: ShellBarTheme = {
+	fg(color: string, value: string) {
+		return `<${color}>${value}</${color}>`;
+	},
+	bold(value: string) {
+		return value;
+	},
+};
+
+const plainTheme: ShellBarTheme = {
+	fg(_color: string, value: string) {
+		return value;
+	},
+	bold(value: string) {
+		return value;
+	},
+};
+
+function model(overrides: Partial<ShellBarModel> = {}): ShellBarModel {
+	return {
+		cwd: "~/work/gentle-pi",
+		branch: "main",
+		dirty: undefined,
+		sessionName: undefined,
+		modelId: "gpt-5.5",
+		effort: "medium",
+		contextPercent: 45,
+		contextWindow: 272_000,
+		costTotal: 9.49,
+		subscription: true,
+		usage: undefined,
+		statuses: [],
+		...overrides,
+	};
+}
+
+test("renderGauge fills cells proportionally to the percentage", () => {
+	assert.equal(renderGauge(45, 8), "▰▰▰▰▱▱▱▱");
+	assert.equal(renderGauge(0, 8), "▱▱▱▱▱▱▱▱");
+	assert.equal(renderGauge(100, 8), "▰▰▰▰▰▰▰▰");
+	assert.equal(renderGauge(null, 8), "▱▱▱▱▱▱▱▱");
+});
+
+test("gaugeTone turns to warning at 80% and error at 95%", () => {
+	assert.equal(gaugeTone(45), "accent");
+	assert.equal(gaugeTone(79.9), "accent");
+	assert.equal(gaugeTone(80), "warning");
+	assert.equal(gaugeTone(95), "error");
+	assert.equal(gaugeTone(null), "dim");
+});
+
+test("formatTokens and formatCost keep the bar compact", () => {
+	assert.equal(formatTokens(950), "950");
+	assert.equal(formatTokens(4_200), "4.2k");
+	assert.equal(formatTokens(272_000), "272k");
+	assert.equal(formatTokens(13_000_000), "13M");
+	assert.equal(formatCost(9.49, true), "$9.49 sub");
+	assert.equal(formatCost(0.004, false), "$0.004");
+});
+
+test("renderShellBar renders one line with the segments in order", () => {
+	const [line, ...rest] = renderShellBar(model(), plainTheme, 160);
+	assert.equal(rest.length, 0);
+	assert.equal(
+		line,
+		"✿ gentle-pi ⟡ ~/work/gentle-pi main ⟡ gpt-5.5 · medium ⟡ ctx ▰▰▰▰▱▱▱▱ 45% ⟡ $9.49 sub",
+	);
+});
+
+test("renderShellBar colors the brand, model, effort, and gauge by role", () => {
+	const [line] = renderShellBar(model(), taggedTheme, 400);
+	assert.match(line, /<accent>✿ gentle-pi<\/accent>/);
+	assert.match(line, /<text>gpt-5\.5<\/text>/);
+	assert.match(line, /<syntaxFunction>medium<\/syntaxFunction>/);
+	assert.match(line, /<accent>▰▰▰▰<\/accent><border>▱▱▱▱<\/border>/);
+	assert.match(line, /<dim>⟡<\/dim>/);
+});
+
+test("renderShellBar shows the branch as dirty-neutral and omits it outside git", () => {
+	const [line] = renderShellBar(model({ branch: null }), plainTheme, 160);
+	assert.match(line, /⟡ ~\/work\/gentle-pi ⟡/);
+});
+
+test("renderShellBar shows the session dirty count next to the branch", () => {
+	const [line] = renderShellBar(model({ dirty: 3 }), taggedTheme, 400);
+	assert.match(line, /<text>main<\/text> <warning>±3<\/warning>/);
+	const [clean] = renderShellBar(model({ dirty: 0 }), plainTheme, 160);
+	assert.doesNotMatch(clean, /±/);
+});
+
+test("renderShellBar adds the subscription windows after the cost when usage is known", () => {
+	const usage = {
+		provider: "openai-codex",
+		plan: "pro",
+		fetchedAt: 0,
+		limits: [{ name: "codex", limitReached: false, windows: [
+			{ label: "5h", usedPercent: 62, windowSeconds: 18_000, resetAt: null },
+			{ label: "week", usedPercent: 31, windowSeconds: 604_800, resetAt: null },
+		] }],
+	};
+	const [line] = renderShellBar(model({ usage }), plainTheme, 200);
+	assert.match(line, /\$9\.49 sub ⟡ codex 5h ▰▰▰▰▰▱▱▱ 62% · week 31%$/);
+});
+
+test("renderShellBar shows an unknown context as a question mark after compaction", () => {
+	const [line] = renderShellBar(model({ contextPercent: null }), plainTheme, 160);
+	assert.match(line, /ctx ▱▱▱▱▱▱▱▱ \?%/);
+});
+
+test("renderShellBar right-aligns the session name when it fits", () => {
+	const [line] = renderShellBar(model({ sessionName: "Release notes" }), plainTheme, 120);
+	assert.equal(visibleWidth(line), 120);
+	assert.match(line, /Release notes$/);
+});
+
+test("renderShellBar appends extension statuses as trailing segments", () => {
+	const [line] = renderShellBar(model({ statuses: ["🔌 MCP: 3 servers\tenabled"] }), plainTheme, 160);
+	assert.match(line, /⟡ 🔌 MCP: 3 servers enabled$/);
+});
+
+test("renderShellBar repaints extension statuses in the bar role, discarding colors the extension embedded", () => {
+	const tagged = { fg: (color: string, text: string) => `<${color}>${text}</${color}>`, bold: (text: string) => text };
+	const [line] = renderShellBar(model({ statuses: ["\x1b[38;2;255;0;0mMCP: 3/3 servers\x1b[0m"] }), tagged, 400);
+	assert.match(line, /<muted>MCP: 3\/3 servers<\/muted>$/);
+	assert.doesNotMatch(line, /\x1b\[/);
+});
+
+test("renderShellBar compacts the path and branch before it sacrifices an extension status", () => {
+	const long = model({ branch: "fix/shell-bar-status-ansi", dirty: 2, statuses: ["MCP: 3/3 servers"] });
+	const [full] = renderShellBar(long, plainTheme, 160);
+	assert.match(full, /~\/work\/gentle-pi fix\/shell-bar-status-ansi ±2 .* MCP: 3\/3 servers$/);
+	const [compact] = renderShellBar(long, plainTheme, 118);
+	assert.ok(visibleWidth(compact) <= 118, `line overflowed: ${visibleWidth(compact)}`);
+	assert.match(compact, /⟡ gentle-pi fix\/shell-bar-… ±2 ⟡/);
+	assert.match(compact, /MCP: 3\/3 servers$/);
+});
+
+test("renderShellBar drops the session name, then trailing segments, before truncating", () => {
+	const wide = model({ sessionName: "Release notes", statuses: ["MCP: 3 servers enabled"] });
+	const [atNinety] = renderShellBar(wide, plainTheme, 90);
+	assert.ok(visibleWidth(atNinety) <= 90, `line overflowed: ${visibleWidth(atNinety)}`);
+	assert.doesNotMatch(atNinety, /Release notes/);
+	assert.match(atNinety, /gpt-5\.5/);
+
+	const [atFifty] = renderShellBar(wide, plainTheme, 50);
+	assert.ok(visibleWidth(atFifty) <= 50, `line overflowed: ${visibleWidth(atFifty)}`);
+	assert.match(atFifty, /^✿ gentle-pi/);
+});
+
+test("shellEnabled stays off inside a Gentle Agents child", () => {
+	assert.equal(shellEnabled({ GENTLE_PI_AGENTS_CHILD: "1" }), false);
+});
+
+test("shellEnabled honors GENTLE_PI_SHELL=0", () => {
+	assert.equal(shellEnabled({}), true);
+	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "1" }), true);
+	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "0" }), false);
+	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "false" }), false);
+});

package/tests/shell-card.test.ts

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { CARD_TONE, renderCard, type Card } from "../lib/shell-card.ts";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+
+// Cards are how Gentle notices look: the same rounded frame as the prompt,
+// with the title in the notice tone. They collapse to one body line when pi
+// asks for it.
+
+const plainTheme = {
+	fg(_color: string, text: string) {
+		return text;
+	},
+};
+
+const taggedTheme = {
+	fg(color: string, text: string) {
+		return `<${color}>${text}</${color}>`;
+	},
+};
+
+const ansiTheme = {
+	fg(_color: string, text: string) {
+		return `\x1b[35m${text}\x1b[0m`;
+	},
+};
+
+function card(overrides: Partial<Card> = {}): Card {
+	return {
+		title: "Gentle AI",
+		subtitle: "review preflight",
+		body: ["Receipt-driven development is enabled, and this worktree holds an unreviewed candidate.", "", "Call the gentle_review tool with inspect and follow the transition it returns."],
+		tone: CARD_TONE.INFO,
+		...overrides,
+	};
+}
+
+test("renderCard draws the rounded frame with the title in the top rule and wraps the body inside", () => {
+	const lines = renderCard(card(), plainTheme, 48, { expanded: true }).map(stripAnsi);
+	assert.match(lines[0], /^╭─ ✿ Gentle AI · review preflight ─+╮$/);
+	assert.match(lines[1], /^│ Receipt-driven development is enabled, and +│$/);
+	for (const line of lines) assert.equal(visibleWidth(line), 48, `"${line}" is not 48 wide`);
+	assert.ok(lines.some((line) => /^│ +│$/.test(line)), "blank body lines keep the frame");
+	assert.ok(lines.some((line) => line.includes("gentle_review")), "every paragraph is rendered when expanded");
+	assert.match(lines[lines.length - 1], /^╰─+╯$/);
+});
+
+test("renderCard collapses to the frame and the first body line with an expand hint", () => {
+	const lines = renderCard(card(), plainTheme, 60, { expanded: false }).map(stripAnsi);
+	assert.equal(lines.length, 3);
+	assert.match(lines[1], /^│ Receipt-driven development is enabled.*… +│$/);
+	assert.equal(visibleWidth(lines[1]), 60);
+});
+
+test("renderCard keeps the rail and its corners in the tone and the rest of the frame in the border color", () => {
+	const info = renderCard(card(), taggedTheme, 80, { expanded: true });
+	assert.match(info[0], /^<customMessageLabel>╭<\/customMessageLabel><border>─ <\/border><customMessageLabel>✿ Gentle AI<\/customMessageLabel> <muted>·<\/muted> <muted>review preflight<\/muted><border> ─+<\/border><border>╮<\/border>$/);
+	assert.match(info[1], /^<customMessageLabel>│<\/customMessageLabel> <text>.*<border>│<\/border>$/);
+	assert.match(info[info.length - 1], /^<customMessageLabel>╰<\/customMessageLabel><border>─+╯<\/border>$/);
+
+	const warning = renderCard(card({ tone: CARD_TONE.WARNING, subtitle: undefined }), taggedTheme, 80, { expanded: true });
+	assert.match(warning[0], /^<warning>╭<\/warning>/);
+	assert.match(warning[0], /<warning>✿ Gentle AI<\/warning>/);
+	assert.match(warning[1], /^<warning>│<\/warning> /);
+	assert.match(warning[warning.length - 1], /^<warning>╰<\/warning>/);
+
+	const error = renderCard(card({ tone: CARD_TONE.ERROR }), taggedTheme, 80, { expanded: true });
+	assert.match(error[0], /<error>✿ Gentle AI<\/error>/);
+	assert.equal(CARD_TONE.SUCCESS, "success");
+});
+
+test("renderCard places a hint at the right end of the top rule without background fill", () => {
+	const lines = renderCard(card(), plainTheme, 60, { expanded: false, hint: "ctrl+o expand" });
+	assert.match(stripAnsi(lines[0]), /^╭─ ✿ Gentle AI · review preflight ─+ ctrl\+o expand ╮$/);
+	assert.equal(visibleWidth(lines[0]), 60);
+
+	assert.doesNotMatch(lines.join("\n"), /\x1b\[44m/);
+});
+
+test("cards remain transparent across content resets and narrow widths", () => {
+	for (const width of [0, 1, 2, 3, 4, 8, 40]) {
+		const lines = renderCard(card({ body: ["red\x1b[0m blue", ""] }), ansiTheme, width, { expanded: true });
+		for (const [row, line] of lines.entries()) {
+			let painted = false, column = 0;
+			for (const token of line.match(/\x1b\[[\d;]*m|[^\x1b]/gu) ?? []) {
+				if (token.startsWith("\x1b")) {
+					for (const code of token.slice(2, -1).split(";").map(Number)) {
+						if (code === 0 || code === 49) painted = false;
+						if (code === 44) painted = true;
+					}
+				} else {
+					assert.equal(painted, false, `row ${row}, cell ${column}`);
+					column += visibleWidth(token);
+				}
+			}
+			assert.equal(painted, false, "background must not leak into host padding");
+			assert.equal(visibleWidth(line), width);
+		}
+	}
+});
+
+test("renderCard accepts a custom glyph and an empty body", () => {
+	const lines = renderCard(card({ glyph: "✎", body: [] }), plainTheme, 40, { expanded: true }).map(stripAnsi);
+	assert.equal(lines.length, 2);
+	assert.match(lines[0], /^╭─ ✎ Gentle AI · review preflight ─+╮$/);
+	assert.match(lines[1], /^╰─+╯$/);
+});
+
+test("renderCard keeps the top rule at width with a two-cell glyph", () => {
+	const lines = renderCard(card({ glyph: "\u{1F339}\uFE0E" }), plainTheme, 60, { expanded: false, hint: "ctrl+o expand" });
+	for (const line of lines) assert.equal(visibleWidth(line), 60, `"${stripAnsi(line)}" is not 60 wide`);
+});
+
+test("renderCard drops the hint before truncating title content", () => {
+	const lines = renderCard(card(), plainTheme, 40, { expanded: false, hint: "ctrl+o expand" }).map(stripAnsi);
+	assert.equal(lines[0], "╭─ ✿ Gentle AI · review preflight ─────╮");
+	assert.ok(!lines[0].includes("ctrl+o"));
+	assert.equal(visibleWidth(lines[0]), 40);
+});
+
+test("renderCard truncates ANSI-styled title content at display width", () => {
+	const lines = renderCard(
+		card({ glyph: "\u{1F339}\uFE0E", title: "Gentle AI review", subtitle: "completed · review acknowledge approved" }),
+		ansiTheme,
+		30,
+		{ expanded: false, hint: "ctrl+o to expand" },
+	);
+	assert.match(stripAnsi(lines[0]), /^╭─ 🌹︎ Gentle AI review.*╮$/);
+	assert.ok(!stripAnsi(lines[0]).includes("ctrl+o"));
+	for (const line of lines) assert.equal(visibleWidth(line), 30, `"${stripAnsi(line)}" is not 30 wide`);
+});
+
+test("renderCard never exceeds extremely narrow supplied widths", () => {
+	for (const width of [0, 1, 2, 3, 4, 5, 8, 16]) {
+		const lines = renderCard(card({ glyph: "\u{1F339}\uFE0E" }), ansiTheme, width, { expanded: true, hint: "ctrl+o to expand" });
+		for (const line of lines) assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
+	}
+});