pi-crew 0.9.53 → 0.9.55

package/src/ui/overlays/help-overlay.ts

@@ -0,0 +1,177 @@
+/**
+ * K-1 — dashboard keybinding cheatsheet overlay.
+ *
+ * Toggled by `?` (bound in keybinding-map.ts). Renders the dashboard's
+ * keybindings grouped by scope (general / navigation / panes / run actions /
+ * mailbox / health) directly from `DASHBOARD_KEYS`, so adding a key in one
+ * place is reflected here automatically.
+ *
+ * Uses the same `innerWidth = max(20, width - 4)` formula as `run-dashboard.ts`
+ * so the overlay's border column aligns with the dashboard's stable-height
+ * blank-padding rows (preserves the "stable overlay height" strength — the
+ * blank rows injected by the dashboard's pad/trim must land in the same
+ * column as this overlay's `│` borders).
+ *
+ * Template origin: `confirm-overlay.ts`.
+ */
+
+import { pad, truncate } from "../../utils/visual.ts";
+import { DASHBOARD_KEYS } from "../keybinding-map.ts";
+import { Box, Text } from "../layout-primitives.ts";
+import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
+
+/** Translate a raw key sequence into a readable token for the cheatsheet. */
+function keyToken(key: string): string {
+	switch (key) {
+		case "\u001b":
+			return "Esc";
+		case "\u001b[A":
+			return "↑";
+		case "\u001b[B":
+			return "↓";
+		case "\r":
+		case "\n":
+			return "Enter";
+		default:
+			return key;
+	}
+}
+
+function keyList(keys: readonly string[]): string {
+	return [...keys].map(keyToken).join("/");
+}
+
+interface HelpEntry {
+	readonly keys: string;
+	readonly label: string;
+}
+
+interface HelpGroup {
+	readonly title: string;
+	readonly entries: readonly HelpEntry[];
+}
+
+const ROOT_LABELS: Record<string, string> = {
+	summary: "summary",
+	artifacts: "artifacts",
+	api: "api",
+	agents: "agents",
+	mailbox: "mailbox",
+	events: "events",
+	output: "output",
+	transcript: "transcript",
+	liveConversation: "live conv",
+	reload: "reload",
+	progressToggle: "progress",
+};
+
+const MAILBOX_LABELS: Record<string, string> = {
+	ack: "ack",
+	nudge: "nudge",
+	compose: "compose",
+	preview: "preview",
+	ackAll: "ack all",
+};
+
+const HEALTH_LABELS: Record<string, string> = {
+	recovery: "recover",
+	killStale: "kill stale",
+	diagnosticExport: "diag export",
+};
+
+function buildHelpGroups(): HelpGroup[] {
+	const paneEntries: HelpEntry[] = Object.entries(DASHBOARD_KEYS.pane).map(([name, keys]) => ({
+		keys: keyList(keys),
+		label: name,
+	}));
+	const rootEntries: HelpEntry[] = Object.entries(DASHBOARD_KEYS.root).map(([name, keys]) => ({
+		keys: keyList(keys),
+		label: ROOT_LABELS[name] ?? name,
+	}));
+	const mailboxEntries: HelpEntry[] = Object.entries(DASHBOARD_KEYS.mailbox)
+		.filter(([name]) => name !== "openDetail")
+		.map(([name, keys]) => ({
+			keys: keyList(keys),
+			label: MAILBOX_LABELS[name] ?? name,
+		}));
+	const healthEntries: HelpEntry[] = Object.entries(DASHBOARD_KEYS.health).map(([name, keys]) => ({
+		keys: keyList(keys),
+		label: HEALTH_LABELS[name] ?? name,
+	}));
+	return [
+		{
+			title: "General",
+			entries: [
+				{
+					keys: keyList(DASHBOARD_KEYS.close),
+					label: "close dashboard",
+				},
+				{
+					keys: keyList(DASHBOARD_KEYS.select),
+					label: "open run status",
+				},
+				{ keys: "?", label: "toggle this help" },
+			],
+		},
+		{
+			title: "Navigation",
+			entries: [
+				{
+					keys: `${keyList(DASHBOARD_KEYS.navigation.up)}/${keyList(DASHBOARD_KEYS.navigation.down)}`,
+					label: "move selection",
+				},
+			],
+		},
+		{ title: "Panes", entries: paneEntries },
+		{ title: "Run actions", entries: rootEntries },
+		{ title: "Mailbox (pane 3)", entries: mailboxEntries },
+		{
+			title: "Health & notifications",
+			entries: [
+				...healthEntries,
+				{
+					keys: keyList(DASHBOARD_KEYS.notification.dismissAll),
+					label: "dismiss notifs",
+				},
+			],
+		},
+	];
+}
+
+export class HelpOverlay {
+	private readonly theme: CrewTheme;
+
+	constructor(theme: unknown = {}) {
+		this.theme = asCrewTheme(theme);
+	}
+
+	invalidate(): void {
+		// Stateless overlay.
+	}
+
+	render(width: number): string[] {
+		// MUST mirror run-dashboard.ts's innerWidth so the dashboard's
+		// stable-height blank-padding rows align with this overlay's borders.
+		const innerWidth = Math.max(20, width - 4);
+		const fg = (color: Parameters<CrewTheme["fg"]>[0], text: string) => this.theme.fg(color, text);
+		const row = (text: string) => `│ ${pad(truncate(text, innerWidth - 1), innerWidth - 1)}│`;
+		const bar = "─".repeat(innerWidth);
+		const top = fg("border", `╭${bar}╮`);
+		const mid = fg("border", `├${bar}┤`);
+		const bot = fg("border", `╰${bar}╯`);
+		const keyCol = 9;
+		const lines: string[] = [top, row(`${fg("accent", "pi-crew dashboard")} ${fg("dim", "— key reference (press ? to close)")}`), mid];
+		for (const group of buildHelpGroups()) {
+			lines.push(row(fg("accent", group.title)));
+			for (let i = 0; i < group.entries.length; i += 2) {
+				const pair = group.entries.slice(i, i + 2);
+				const cell = (entry: HelpEntry) => `${this.theme.bold(pad(entry.keys, keyCol))}${fg("dim", truncate(entry.label, 16))}`;
+				lines.push(row(pair.map(cell).join("   ")));
+			}
+		}
+		lines.push(bot);
+		const box = new Box(0, 0);
+		for (const line of lines) box.addChild(new Text(line));
+		return box.render(width);
+	}
+}

package/src/ui/overlays/mailbox-compose-overlay.ts

@@ -0,0 +1,181 @@
+import type { MailboxDirection } from "../../state/mailbox.ts";
+import { pad, truncate } from "../../utils/visual.ts";
+import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
+import { ConfirmOverlay } from "./confirm-overlay.ts";
+import { renderComposePreview } from "./mailbox-compose-preview.ts";
+
+export interface MailboxComposePayload {
+	from: string;
+	to: string;
+	body: string;
+	taskId?: string;
+	direction: MailboxDirection;
+}
+
+export type MailboxComposeResult = { type: "submit"; payload: MailboxComposePayload } | { type: "cancel" };
+
+type FieldName = "from" | "to" | "body" | "taskId" | "direction";
+
+const FIELD_ORDER: FieldName[] = ["from", "to", "body", "taskId", "direction"];
+
+export class MailboxComposeOverlay {
+	private readonly done: (result: MailboxComposeResult) => void;
+	private readonly theme: CrewTheme;
+	private fields: MailboxComposePayload = {
+		from: "operator",
+		to: "leader",
+		body: "",
+		direction: "inbox",
+	};
+	private activeField = 1;
+	private error: string | undefined;
+	private preview = false;
+	private confirm: ConfirmOverlay | undefined;
+
+	constructor(opts: {
+		done: (result: MailboxComposeResult) => void;
+		theme?: unknown;
+		initial?: Partial<MailboxComposePayload>;
+	}) {
+		this.done = opts.done;
+		this.theme = asCrewTheme(opts.theme ?? {});
+		this.fields = { ...this.fields, ...opts.initial };
+	}
+
+	invalidate(): void {
+		// State is updated synchronously from input.
+	}
+
+	render(width: number): string[] {
+		if (this.confirm) return this.confirm.render(width);
+		const inner = Math.max(24, width - 4);
+		const formWidth = this.preview ? Math.max(24, Math.floor(inner * 0.6)) : inner;
+		const lines = [
+			this.theme.bold("Compose mailbox message"),
+			this.preview
+				? "P close preview · Tab cycle · Enter submit · ESC discard"
+				: "P preview · Tab cycle · Enter submit · ESC discard",
+			...(this.error ? [this.theme.fg("error", this.error)] : []),
+			this.fieldLine("from", formWidth),
+			this.fieldLine("to", formWidth),
+			this.fieldLine("body", formWidth),
+			this.fieldLine("taskId", formWidth),
+			`${this.activeField === 4 ? "›" : " "} [${this.fields.direction === "outbox" ? "x" : " "}] Send to outbox`,
+		];
+		if (!this.preview) return lines.map((line) => pad(truncate(line, inner), inner));
+		const previewLines = renderComposePreview(this.fields.body, Math.max(20, inner - formWidth - 3), this.theme);
+		const max = Math.max(lines.length, previewLines.length);
+		const split: string[] = [];
+		for (let index = 0; index < max; index += 1) {
+			split.push(
+				`${pad(truncate(lines[index] ?? "", formWidth), formWidth)} │ ${truncate(previewLines[index] ?? "", inner - formWidth - 3)}`,
+			);
+		}
+		return split;
+	}
+
+	private fieldLine(field: Exclude<FieldName, "direction">, width: number): string {
+		const active = FIELD_ORDER[this.activeField] === field;
+		const label = field === "taskId" ? "taskId" : field;
+		return `${active ? "›" : " "} ${label}: ${truncate(this.fields[field] ?? "", Math.max(8, width - label.length - 5))}`;
+	}
+
+	private activeName(): FieldName {
+		return FIELD_ORDER[this.activeField] ?? "body";
+	}
+
+	private appendText(data: string): void {
+		const field = this.activeName();
+		if (field === "direction") return;
+		this.fields = {
+			...this.fields,
+			[field]: `${this.fields[field] ?? ""}${data}`,
+		};
+		this.error = undefined;
+	}
+
+	private backspace(): void {
+		const field = this.activeName();
+		if (field === "direction") return;
+		this.fields = {
+			...this.fields,
+			[field]: (this.fields[field] ?? "").slice(0, -1),
+		};
+	}
+
+	private submit(): void {
+		const body = this.fields.body.trim();
+		if (!body) {
+			this.error = "Body is required.";
+			return;
+		}
+		if (!this.fields.to.trim()) {
+			this.error = "Recipient is required.";
+			return;
+		}
+		this.done({
+			type: "submit",
+			payload: {
+				...this.fields,
+				from: this.fields.from.trim() || "operator",
+				to: this.fields.to.trim(),
+				body,
+				taskId: this.fields.taskId?.trim() || undefined,
+			},
+		});
+	}
+
+	private cancel(): void {
+		if (this.fields.body.length <= 50) {
+			this.done({ type: "cancel" });
+			return;
+		}
+		this.confirm = new ConfirmOverlay(
+			{
+				title: "Discard draft?",
+				body: `Body has ${this.fields.body.length} chars. Y=discard, N=continue editing`,
+				dangerLevel: "medium",
+				defaultAction: "cancel",
+			},
+			(confirmed) => {
+				this.confirm = undefined;
+				if (confirmed) this.done({ type: "cancel" });
+			},
+			this.theme,
+		);
+	}
+
+	handleInput(data: string): void {
+		if (this.confirm) {
+			this.confirm.handleInput(data);
+			return;
+		}
+		if (data === "\u001b") {
+			this.cancel();
+			return;
+		}
+		if (data === "P") {
+			this.preview = !this.preview;
+			return;
+		}
+		if (data === "\t") {
+			this.activeField = (this.activeField + 1) % FIELD_ORDER.length;
+			return;
+		}
+		if (data === " ") {
+			if (this.activeName() === "direction") this.fields.direction = this.fields.direction === "inbox" ? "outbox" : "inbox";
+			else this.appendText(data);
+			return;
+		}
+		if (data === "\b" || data === "\u007f") {
+			this.backspace();
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			if (this.activeName() === "body" || this.fields.body.trim()) this.submit();
+			else this.activeField = (this.activeField + 1) % FIELD_ORDER.length;
+			return;
+		}
+		if (data.length === 1 && data >= " ") this.appendText(data);
+	}
+}

package/src/ui/overlays/mailbox-compose-preview.ts

@@ -0,0 +1,78 @@
+import { truncate } from "../../utils/visual.ts";
+import type { CrewTheme } from "../theme-adapter.ts";
+import { asCrewTheme } from "../theme-adapter.ts";
+
+export type MarkdownToken = {
+	type: "heading" | "code-block" | "list-item" | "paragraph";
+	level?: number;
+	text: string;
+};
+
+function stripInlineMarkdown(text: string): string {
+	return text
+		.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+		.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+		.replace(/`([^`]+)`/g, "$1")
+		.replace(/\*\*([^*]+)\*\*/g, "$1")
+		.replace(/\*([^*]+)\*/g, "$1");
+}
+
+export function tokenizeMarkdown(body: string): MarkdownToken[] {
+	const tokens: MarkdownToken[] = [];
+	const lines = body.split(/\r?\n/);
+	let inCode = false;
+	let codeLines: string[] = [];
+	for (const line of lines) {
+		if (line.trim().startsWith("```")) {
+			if (inCode) {
+				tokens.push({ type: "code-block", text: codeLines.join("\n") });
+				codeLines = [];
+				inCode = false;
+			} else inCode = true;
+			continue;
+		}
+		if (inCode) {
+			codeLines.push(line);
+			continue;
+		}
+		const heading = /^(#{1,3})\s+(.+)$/.exec(line);
+		if (heading) {
+			tokens.push({
+				type: "heading",
+				level: heading[1]!.length,
+				text: stripInlineMarkdown(heading[2]!),
+			});
+			continue;
+		}
+		const list = /^\s*(?:[-*]|\d+\.)\s+(.+)$/.exec(line);
+		if (list) {
+			tokens.push({
+				type: "list-item",
+				text: stripInlineMarkdown(list[1]!),
+			});
+			continue;
+		}
+		if (line.trim())
+			tokens.push({
+				type: "paragraph",
+				text: stripInlineMarkdown(line.trim()),
+			});
+	}
+	if (inCode && codeLines.length) tokens.push({ type: "code-block", text: codeLines.join("\n") });
+	return tokens;
+}
+
+function renderToken(token: MarkdownToken, width: number, theme: CrewTheme): string[] {
+	const safeWidth = Math.max(10, width);
+	if (token.type === "heading") return [truncate(theme.bold(`${"#".repeat(token.level ?? 1)} ${token.text}`), safeWidth)];
+	if (token.type === "list-item") return [truncate(`• ${token.text}`, safeWidth)];
+	if (token.type === "code-block") return ["```", ...token.text.split(/\r?\n/).map((line) => truncate(`  ${line}`, safeWidth)), "```"];
+	return [truncate(token.text, safeWidth)];
+}
+
+export function renderComposePreview(body: string, width: number, themeLike: unknown = {}): string[] {
+	const theme = asCrewTheme(themeLike);
+	const tokens = tokenizeMarkdown(body);
+	if (!tokens.length) return [theme.fg("dim", "Preview: (empty)")];
+	return [theme.bold("Preview"), ...tokens.flatMap((token) => renderToken(token, width, theme))];
+}

package/src/ui/overlays/mailbox-detail-overlay.ts

@@ -0,0 +1,155 @@
+import { type MailboxMessage, readDeliveryState, readMailbox } from "../../state/mailbox.ts";
+import { loadRunManifestById } from "../../state/state-store.ts";
+import { pad, truncate } from "../../utils/visual.ts";
+import { keyOf } from "../key-utils.ts";
+import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
+
+export type MailboxAction =
+	| { type: "ack"; messageId: string }
+	| { type: "nudge"; agentId?: string }
+	| { type: "compose" }
+	| { type: "ackAll" }
+	| { type: "close" };
+
+export class MailboxDetailOverlay {
+	private readonly runId: string;
+	private readonly cwd: string;
+	private readonly done: (action: MailboxAction | undefined) => void;
+	private readonly theme: CrewTheme;
+	private inbox: MailboxMessage[] = [];
+	private outbox: MailboxMessage[] = [];
+	private side: "inbox" | "outbox" = "inbox";
+	private selected = 0;
+	private expanded = false;
+	private lastRefreshedTaskCount = 0;
+	private needsRefresh = true;
+
+	constructor(opts: {
+		runId: string;
+		cwd: string;
+		done: (action: MailboxAction | undefined) => void;
+		theme?: unknown;
+	}) {
+		this.runId = opts.runId;
+		this.cwd = opts.cwd;
+		this.done = opts.done;
+		this.theme = asCrewTheme(opts.theme ?? {});
+		this.refresh();
+	}
+
+	private refresh(): void {
+		const loaded = loadRunManifestById(this.cwd, this.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
+		if (!loaded) return;
+		// Track task count changes to trigger re-render
+		const taskCount = loaded.tasks.length;
+		if (taskCount !== this.lastRefreshedTaskCount) {
+			this.lastRefreshedTaskCount = taskCount;
+			this.needsRefresh = true;
+		}
+		const delivery = readDeliveryState(loaded.manifest).messages;
+		const applyDelivery = (message: MailboxMessage): MailboxMessage => ({
+			...message,
+			status: delivery[message.id] ?? message.status,
+		});
+		const taskIds = loaded.tasks.map((task) => task.id);
+		this.inbox = [
+			...readMailbox(loaded.manifest, "inbox"),
+			...taskIds.flatMap((taskId) => readMailbox(loaded.manifest, "inbox", taskId)),
+		]
+			.map(applyDelivery)
+			.reverse();
+		this.outbox = [
+			...readMailbox(loaded.manifest, "outbox"),
+			...taskIds.flatMap((taskId) => readMailbox(loaded.manifest, "outbox", taskId)),
+		]
+			.map(applyDelivery)
+			.reverse();
+		this.selected = Math.min(this.selected, Math.max(0, this.current().length - 1));
+	}
+
+	private current(): MailboxMessage[] {
+		return this.side === "inbox" ? this.inbox : this.outbox;
+	}
+
+	private selectedMessage(): MailboxMessage | undefined {
+		return this.current()[this.selected];
+	}
+
+	invalidate(): void {
+		this.needsRefresh = true;
+	}
+
+	render(width: number): string[] {
+		if (this.needsRefresh) {
+			this.refresh();
+			this.needsRefresh = false;
+		}
+		const inner = Math.max(40, width - 4);
+		const col = Math.max(18, Math.floor((inner - 3) / 2));
+		const lines = [
+			this.theme.bold(`Mailbox detail · ${this.runId}`),
+			"Tab side · ↑/↓ select · Enter expand · A ack · N nudge · C compose · X ack all · ESC close",
+			`${pad(this.theme.bold("Inbox"), col)} │ ${pad(this.theme.bold("Outbox"), col)}`,
+		];
+		const max = Math.max(this.inbox.length, this.outbox.length, 1);
+		for (let index = 0; index < Math.min(max, 12); index += 1) {
+			lines.push(`${this.row(this.inbox[index], "inbox", index, col)} │ ${this.row(this.outbox[index], "outbox", index, col)}`);
+		}
+		const selected = this.selectedMessage();
+		if (this.expanded && selected) {
+			lines.push("─".repeat(Math.min(inner, 72)));
+			lines.push(`${selected.from} → ${selected.to}${selected.taskId ? ` (${selected.taskId})` : ""} · ${selected.status}`);
+			lines.push(...selected.body.split(/\r?\n/).map((line) => truncate(line, inner)));
+		}
+		if (!this.inbox.length && !this.outbox.length) lines.push("Mailbox is empty.");
+		return lines.map((line) => truncate(line, inner));
+	}
+
+	private row(message: MailboxMessage | undefined, side: "inbox" | "outbox", index: number, width: number): string {
+		if (!message) return pad("", width);
+		const marker = this.side === side && this.selected === index ? "›" : " ";
+		const status = message.status === "acknowledged" ? "✓" : "!";
+		return pad(truncate(`${marker}${status} ${message.from}->${message.to}: ${message.body.replace(/\s+/g, " ")}`, width), width);
+	}
+
+	handleInput(data: string): void {
+		if (data === "\u001b" || data === "q") {
+			this.done({ type: "close" });
+			return;
+		}
+		if (data === "\t") {
+			this.side = this.side === "inbox" ? "outbox" : "inbox";
+			this.selected = Math.min(this.selected, Math.max(0, this.current().length - 1));
+			return;
+		}
+		if (data === "k" || keyOf(data) === "up") {
+			this.selected = Math.max(0, this.selected - 1);
+			return;
+		}
+		if (data === "j" || keyOf(data) === "down") {
+			this.selected = Math.min(Math.max(0, this.current().length - 1), this.selected + 1);
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			this.expanded = !this.expanded;
+			return;
+		}
+		if (data === "A") {
+			const message = this.selectedMessage();
+			if (message) this.done({ type: "ack", messageId: message.id });
+			return;
+		}
+		if (data === "N") {
+			this.done({
+				type: "nudge",
+				agentId: this.selectedMessage()?.taskId,
+			});
+			return;
+		}
+		if (data === "C") {
+			this.done({ type: "compose" });
+			return;
+		}
+		if (data === "X") this.done({ type: "ackAll" });
+	}
+}

package/src/ui/pi-ui-compat.ts

@@ -0,0 +1,68 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export interface WorkingIndicatorOptions {
+	frames?: string[];
+	intervalMs?: number;
+}
+
+type UiContext = Pick<ExtensionContext, "ui">;
+type ExtensionUi = ExtensionContext["ui"];
+type WidgetContent = string[] | ((tui: unknown, theme: unknown) => unknown);
+type WidgetOptions = Parameters<ExtensionUi["setWidget"]>[2];
+type WidgetOptionsWithPersist = WidgetOptions & { persist?: boolean };
+
+type CustomOptions = Parameters<ExtensionUi["custom"]>[1];
+
+type CustomFactory<T> = (tui: unknown, theme: unknown, keybindings: unknown, done: (result: T) => void) => unknown;
+type GenericCustom = <T>(factory: CustomFactory<T>, options?: CustomOptions) => Promise<T>;
+
+function maybeRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
+}
+
+export function requestRender(ctx: UiContext): void {
+	requestRenderTarget(ctx.ui);
+}
+
+export function requestRenderTarget(target: unknown): void {
+	const record = maybeRecord(target);
+	const fn = record?.requestRender;
+	if (typeof fn === "function") fn.call(target);
+}
+
+export function setWorkingIndicator(ctx: UiContext, options?: WorkingIndicatorOptions): void {
+	const record = maybeRecord(ctx.ui);
+	const fn = record?.setWorkingIndicator;
+	if (typeof fn === "function") fn.call(ctx.ui, options);
+}
+
+export function setExtensionWidget(
+	ctx: UiContext,
+	key: string,
+	content: WidgetContent | undefined,
+	options?: WidgetOptionsWithPersist,
+): void {
+	const { persist: _persist, ...widgetOptions } = options ?? {};
+	ctx.ui.setWidget(key, content as never, widgetOptions as WidgetOptions);
+}
+
+type FooterFactory = (tui: unknown, theme: unknown, footerData: unknown) => unknown;
+
+/** Install a custom footer component, or pass `undefined` to restore pi's built-in footer.
+ * No-op when the host UI predates the `setFooter` API. */
+export function setFooter(ctx: UiContext | undefined, factory: FooterFactory | undefined): void {
+	if (!ctx) return;
+	const record = maybeRecord(ctx.ui);
+	const fn = record?.setFooter;
+	if (typeof fn === "function") fn.call(ctx.ui, factory as never);
+}
+
+export function showCustom<T>(ctx: UiContext, factory: CustomFactory<T>, options?: CustomOptions): Promise<T> {
+	const custom = ctx.ui.custom as unknown as GenericCustom;
+	return custom<T>(factory, options);
+}
+
+export function setStatusFallback(ctx: UiContext, key: string, lines: string | readonly string[] | undefined, segment?: string): void {
+	const text = typeof lines === "string" ? lines : lines ? [...lines].join("\n") : undefined;
+	ctx.ui.setStatus(segment ? `${key}:${segment}` : key, text);
+}