pi-tui-footer 1.2.0

package/extensions/index.ts

@@ -0,0 +1,457 @@
+/**
+ * pi-tui-footer — full TUI polish for pi: Pi logo header,
+ * Starship-style footer, rounded editor with embedded working status,
+ * thinking peek preview, rounded tool frames, and turn telemetry.
+ *
+ * Integrated from:
+ *   - pi-open-tui (v0.3.7, MIT, by OldSun, https://github.com/OldSuns/pi-open-tui)
+ *   - pi-rounded-tools (v0.1.3, MIT, by OrionPax, https://github.com/orionpax1997/pi-rounded-tools)
+ *
+ * Security audit notes:
+ *   - zero third-party runtime deps (pi core bundles + node built-ins only)
+ *   - execFile runs only hardcoded git / runtime version commands (no shell
+ *     injection surface); fs access limited to ~/.pi/agent/pi-tui.json
+ *   - no network / eval / obfuscation / credential reads
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type OpenTuiConfig, DEFAULT_CONFIG, ensureConfigExists, loadConfig, saveConfig } from "./config.ts";
+import { installEditor } from "./editor.ts";
+import { installFooter } from "./footer.ts";
+import { installHeader } from "./header.ts";
+import { emptyGitStatus, readGitStatus } from "./git.ts";
+import { readRuntimeInfo } from "./runtime.ts";
+import { RoundedToolsManager } from "./rounded-tools.ts";
+import { SessionLifecycle } from "./session-lifecycle.ts";
+import { registerSettingsCommand } from "./settings-command.ts";
+import { formatTurnTelemetry, TurnTelemetryTracker } from "./telemetry.ts";
+import {
+	createInitialState,
+	getModelMeta,
+	invalidateUsageCache,
+	type FooterState,
+} from "./state.ts";
+import { resolveGlyphs } from "./icons.ts";
+import {
+	buildPeekLabel,
+	collectPeekParts,
+	createPeekState,
+	reducePeek,
+	type PeekState,
+} from "./peek.ts";
+
+type PendingUiChange = "install" | "uninstall";
+const HIDDEN_THINKING_HORIZONTAL_PADDING = 2;
+// Pi's fullscreen transcript can reserve one more column for its scrollbar.
+const HIDDEN_THINKING_SCROLLBAR_RESERVE = 1;
+
+export function getPendingUiChange(enabled: boolean, active: boolean): PendingUiChange | undefined {
+	if (enabled === active) return undefined;
+	return enabled ? "install" : "uninstall";
+}
+
+function isTuiContext(ctx: ExtensionContext): boolean {
+	try {
+		const mode = (ctx as ExtensionContext & { mode?: string }).mode;
+		return ctx.hasUI && (mode === undefined || mode === "tui");
+	} catch {
+		return false;
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	const sessionLifecycle = new SessionLifecycle();
+	const state: FooterState = createInitialState();
+	const turnTelemetry = new TurnTelemetryTracker();
+	const roundedTools = new RoundedToolsManager(pi);
+
+	let config: OpenTuiConfig = structuredClone(DEFAULT_CONFIG);
+	let active = false;
+	let lastCtx: ExtensionContext | undefined;
+	let requestFooterRender: (() => void) | undefined;
+	let workingTimer: ReturnType<typeof setInterval> | undefined;
+	let cleanupHeader: (() => void) | undefined;
+	let cleanupFooter: (() => void) | undefined;
+	let editor: ReturnType<typeof installEditor> | undefined;
+	let pendingUiChange: PendingUiChange | undefined;
+
+	// thinking-peek state (rendered by Pi inside its hidden-thinking block)
+	const peek: PeekState = createPeekState();
+	let peekFrame = 0;
+	let peekSettleTimer: ReturnType<typeof setTimeout> | undefined;
+	let peekTaskEpoch = 0; // bumped at every agent task boundary
+	let peekLabelActive = false;
+
+	const getThinkingLevel = () => (sessionLifecycle.isCurrent() ? pi.getThinkingLevel() : "off");
+
+	/** True while the agent is running (false during session-restore replay). */
+	const isAgentIdle = (ctx: ExtensionContext): boolean => {
+		try {
+			return (ctx as ExtensionContext & { isIdle?: () => boolean }).isIdle?.() === true;
+		} catch {
+			return false;
+		}
+	};
+
+	/** Pi decides whether this label is visible; our toggle only controls updates. */
+	const isPeekEnabled = () => sessionLifecycle.isCurrent() && config.enabled && config.thinkingPeek.lines > 0 && active;
+
+	/** Keep each native hidden-thinking label row within Pi's narrowest transcript width. */
+	const hiddenThinkingLabelWidth = (): number => {
+		if (!editor) throw new Error("Open TUI editor is not installed");
+		return Math.max(
+			1,
+			editor.getViewportWidth() - HIDDEN_THINKING_HORIZONTAL_PADDING - HIDDEN_THINKING_SCROLLBAR_RESERVE,
+		);
+	};
+
+	const setPeekLabel = (ctx?: ExtensionContext): void => {
+		if (!isPeekEnabled() || peek.phase === "idle") return;
+		const target = ctx ?? lastCtx;
+		if (!target || !isTuiContext(target)) return;
+		if (!editor) throw new Error("Open TUI editor is not installed");
+		editor.setLatestHiddenThinkingLabel(
+			buildPeekLabel(
+				peek,
+				peekFrame,
+				resolveGlyphs(config.icons.mode),
+				hiddenThinkingLabelWidth(),
+				config.thinkingPeek.lines,
+			),
+		);
+		peekLabelActive = true;
+	};
+
+	const clearPeekLabel = (ctx?: ExtensionContext): void => {
+		if (!peekLabelActive) return;
+		const target = ctx ?? lastCtx;
+		if (!target || !isTuiContext(target)) return;
+		// The global reset is safe here: every completed message returns to Pi's native label.
+		target.ui.setHiddenThinkingLabel();
+		peekLabelActive = false;
+	};
+
+	/** Reset peek state to idle and cancel any scheduled cleanup. */
+	const resetPeek = () => {
+		peek.phase = "idle";
+		peek.tail = "";
+		editor?.resetHiddenThinkingLabelTarget();
+		if (peekSettleTimer) {
+			clearTimeout(peekSettleTimer);
+			peekSettleTimer = undefined;
+		}
+	};
+
+	const applyUi = (ctx: ExtensionContext) => {
+		if (!isTuiContext(ctx)) return;
+		if (!config.enabled) {
+			uninstallUi(ctx);
+			return;
+		}
+		if (!active) {
+			cleanupHeader = installHeader(pi, ctx);
+			cleanupFooter = installFooter(
+				ctx,
+				() => state,
+				() => config,
+				() => getModelMeta(ctx, getThinkingLevel, config.footerSegments.capitalizeProviderName),
+				{
+					setRequestRender: (fn) => {
+						requestFooterRender = fn ?? undefined;
+					},
+					scheduleGitRefresh: () => {
+						void scheduleGitRefresh(ctx);
+					},
+				},
+			);
+			editor = installEditor(pi, ctx, config.cursorStyle, config.fullscreen.wheelScrollLines);
+			active = true;
+		}
+	};
+
+	const uninstallUi = (ctx: ExtensionContext) => {
+		if (!isTuiContext(ctx)) return;
+		if (active) {
+			cleanupHeader?.();
+			cleanupFooter?.();
+			editor?.cleanup();
+			cleanupHeader = undefined;
+			cleanupFooter = undefined;
+			editor = undefined;
+			requestFooterRender = undefined;
+			resetPeek();
+			clearPeekLabel(ctx);
+			active = false;
+		}
+	};
+
+	const scheduleGitRefresh = async (ctx: ExtensionContext) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		const segs = config.footerSegments;
+		if (!segs.gitBranch && !segs.gitStatus && !segs.gitCommit) {
+			state.git = emptyGitStatus();
+			requestFooterRender?.();
+			return;
+		}
+		const generation = sessionLifecycle.currentGeneration();
+		const cwd = ctx.cwd;
+		const git = await readGitStatus(cwd, {
+			readCommit: true,
+			readTag: segs.gitCommit,
+			readCounts: segs.gitStatus,
+		});
+		if (!sessionLifecycle.isCurrent(generation)) return;
+		state.git = git;
+		requestFooterRender?.();
+	};
+
+	const refreshRuntime = async (ctx: ExtensionContext) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		const generation = sessionLifecycle.currentGeneration();
+		const cwd = ctx.cwd;
+		const runtime = await readRuntimeInfo(cwd);
+		if (!sessionLifecycle.isCurrent(generation)) return;
+		state.runtime = runtime;
+		requestFooterRender?.();
+	};
+
+	const applyRoundedTools = (ctx: ExtensionContext) => {
+		roundedTools.apply(config.enabled && config.roundedTools, ctx.cwd);
+	};
+
+	// Register rounded tool renderers at load time (before session_start) so a
+	// /reload transcript rebuild — which pi runs BEFORE emitting session_start —
+	// constructs historical tool-call components with the wrapped renderers.
+	// session_start re-registers with the real session cwd afterwards, which
+	// corrects the execute closure for relative-path tools. Toggling the
+	// setting re-registers for new components; already-rendered historical
+	// components keep their current frames until the next transcript rebuild
+	// (compaction / resume / tree navigation / thinking-block toggle).
+	const initialConfig = loadConfig();
+	config = initialConfig;
+	roundedTools.init(initialConfig.enabled && initialConfig.roundedTools);
+
+	const refreshInteractiveState = (ctx: ExtensionContext, project = false) => {
+		if (!sessionLifecycle.isCurrent() || !ctx.hasUI) return;
+		if (project) {
+			void scheduleGitRefresh(ctx);
+			void refreshRuntime(ctx);
+		}
+		requestFooterRender?.();
+	};
+
+	const startWorkingTimer = () => {
+		stopWorkingTimer();
+		const tick = () => {
+			if (!sessionLifecycle.isCurrent() || !active) return;
+			requestFooterRender?.();
+		};
+		tick();
+		workingTimer = setInterval(tick, 250);
+		workingTimer.unref?.();
+	};
+
+	const stopWorkingTimer = () => {
+		if (workingTimer) {
+			clearInterval(workingTimer);
+			workingTimer = undefined;
+		}
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		sessionLifecycle.start();
+		lastCtx = ctx;
+		state.sessionStartEpoch = Date.now();
+		state.workingSince = undefined;
+		state.lastDoneIn = undefined;
+		invalidateUsageCache();
+
+		ensureConfigExists();
+		config = loadConfig((msg, level) => ctx.ui.notify(msg, level));
+		clearPeekLabel(ctx);
+
+		applyUi(ctx);
+		applyRoundedTools(ctx);
+
+		refreshInteractiveState(ctx, true);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		sessionLifecycle.shutdown();
+		stopWorkingTimer();
+		if (active) {
+			uninstallUi(ctx);
+		}
+		lastCtx = undefined;
+	});
+
+	pi.on("agent_start", (event, _ctx) => {
+		turnTelemetry.handle(event);
+		if (!sessionLifecycle.isCurrent()) return;
+		// agent_start also covers custom-message and continuation-triggered tasks
+		// that do not emit a user message_start event.
+		peekTaskEpoch++;
+		state.workingSince = Date.now();
+		state.lastDoneIn = undefined;
+		startWorkingTimer();
+	});
+
+	pi.on("agent_end", (_event, _ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		stopWorkingTimer();
+		if (state.workingSince !== undefined) {
+			state.lastDoneIn = Date.now() - state.workingSince;
+			state.workingSince = undefined;
+		}
+		requestFooterRender?.();
+	});
+
+	pi.on("turn_start", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("message_start", (event, ctx) => {
+		turnTelemetry.handle(event);
+		if (!sessionLifecycle.isCurrent() || isAgentIdle(ctx)) return;
+		const role = event.message?.role;
+		if (role === "user") {
+			// Restore Pi's native label until real thinking arrives. The task epoch is
+			// advanced by agent_start so custom/no-user tasks are covered too.
+			resetPeek();
+			clearPeekLabel(ctx);
+		} else if (role === "assistant") {
+			resetPeek();
+			clearPeekLabel(ctx);
+		}
+	});
+
+	pi.on("message_update", (event, ctx) => {
+		turnTelemetry.handle(event);
+		if (!sessionLifecycle.isCurrent() || isAgentIdle(ctx)) return;
+		if (!isPeekEnabled()) return;
+		const message = event.message;
+		if (!message || message.role !== "assistant") return;
+		if (peek.phase === "done") return;
+		const parts = collectPeekParts(message.content);
+		const next = reducePeek(peek, parts);
+		const changed = next.phase !== peek.phase || next.tail !== peek.tail;
+		peek.phase = next.phase;
+		peek.tail = next.tail;
+		if (!changed) return;
+		if (peek.phase === "thinking") {
+			peekFrame++;
+			setPeekLabel(ctx);
+		} else if (peek.phase === "done") {
+			setPeekLabel(ctx);
+		}
+	});
+
+	pi.on("tool_execution_start", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("turn_end", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("agent_settled", (event, ctx) => {
+		const telemetry = turnTelemetry.handle(event);
+		if (telemetry && config.enabled && config.telemetry.enabled && isTuiContext(ctx)) {
+			const message = formatTurnTelemetry(telemetry, ctx.ui.theme, config.telemetry, config.icons.mode);
+			if (message) ctx.ui.notify(message, "info");
+		}
+		// Only clear the peek label when this task is still the current one.
+		const settleEpoch = peekTaskEpoch;
+		if (peekSettleTimer) clearTimeout(peekSettleTimer);
+		peekSettleTimer = setTimeout(() => {
+			peekSettleTimer = undefined;
+			if (!sessionLifecycle.isCurrent() || peekTaskEpoch !== settleEpoch) return;
+			resetPeek();
+			clearPeekLabel(ctx);
+		}, 300);
+	});
+
+	pi.on("model_select", (_event, ctx) => {
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("thinking_level_select", (_event, ctx) => {
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("message_end", (event, ctx) => {
+		turnTelemetry.handle(event);
+		if (!sessionLifecycle.isCurrent()) return;
+		if (event.message?.role === "assistant" && peek.phase === "thinking") {
+			// Sub-message finished (answer text or a tool call): freeze the peek line.
+			peek.phase = "done";
+			setPeekLabel(ctx);
+		}
+		invalidateUsageCache();
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("tool_execution_end", (_event, ctx) => {
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("session_compact", (_event, ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		invalidateUsageCache();
+		refreshInteractiveState(ctx);
+	});
+
+	pi.on("session_tree", (_event, ctx) => {
+		if (!sessionLifecycle.isCurrent()) return;
+		invalidateUsageCache();
+		refreshInteractiveState(ctx);
+	});
+
+	registerSettingsCommand(pi, {
+		getConfig: () => config,
+		onConfigChanged: (newConfig) => {
+			const wasEnabled = config.enabled;
+			const wasRoundedTools = config.roundedTools;
+			const cursorStyleChanged = config.cursorStyle !== newConfig.cursorStyle;
+			const wheelScrollLinesChanged = config.fullscreen.wheelScrollLines !== newConfig.fullscreen.wheelScrollLines;
+			const thinkingPeekLinesChanged = config.thinkingPeek.lines !== newConfig.thinkingPeek.lines;
+			saveConfig(newConfig);
+			config = newConfig;
+			if (newConfig.thinkingPeek.lines === 0 || !newConfig.enabled) {
+				resetPeek();
+				clearPeekLabel(lastCtx);
+			} else if (thinkingPeekLinesChanged && peekLabelActive) {
+				setPeekLabel(lastCtx);
+			}
+			if (cursorStyleChanged && active && editor) {
+				editor.setCursorStyle(newConfig.cursorStyle);
+			}
+			if (wheelScrollLinesChanged && active && editor) {
+				editor.setWheelScrollLines(newConfig.fullscreen.wheelScrollLines);
+			}
+			if (lastCtx) {
+				pendingUiChange = getPendingUiChange(newConfig.enabled, active);
+			}
+			if (lastCtx && (wasRoundedTools !== newConfig.roundedTools || wasEnabled !== newConfig.enabled)) {
+				applyRoundedTools(lastCtx);
+			}
+			const gitNeeded = newConfig.footerSegments.gitBranch || newConfig.footerSegments.gitStatus || newConfig.footerSegments.gitCommit;
+			if (lastCtx && gitNeeded) {
+				void scheduleGitRefresh(lastCtx);
+			} else {
+				state.git = emptyGitStatus();
+			}
+			requestFooterRender?.();
+		},
+		onOverlayClosed: () => {
+			if (!lastCtx || pendingUiChange === undefined) return;
+			const change = pendingUiChange;
+			pendingUiChange = undefined;
+			if (!config.enabled || change === "uninstall") {
+				uninstallUi(lastCtx);
+			} else {
+				applyUi(lastCtx);
+			}
+		},
+	});
+}

package/extensions/peek.ts

@@ -0,0 +1,168 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { IconGlyphs } from "./icons.ts";
+import { sanitizeStatus } from "./utils.ts";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const MAX_PEEK_LINES = 2;
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export type PeekPhase = "idle" | "thinking" | "done";
+
+export interface PeekState {
+	phase: PeekPhase;
+	tail: string;
+}
+
+export interface PeekMessageParts {
+	thinking: string;
+	text: string;
+}
+
+function stringValue(value: unknown): string | undefined {
+	return typeof value === "string" ? value : undefined;
+}
+
+const normalizePeekLineCount = (lineCount: number): number => Math.max(1, Math.min(MAX_PEEK_LINES, Math.floor(lineCount)));
+
+/**
+ * Pure phase machine for one assistant-message update.
+ *
+ * Thinking text is cumulative: once the answer starts, later updates still
+ * carry the full thinking block alongside new text. To keep the spinner honest:
+ * - idle + thinking        -> thinking (spinner starts)
+ * - idle + thinking + text -> done    (already answered, never spin)
+ * - thinking + text        -> done    (answer started: stop spinner)
+ * - done + thinking        -> done    (never restart the spinner)
+ * - any + text only        -> idle stays idle (plain answer, nothing to peek)
+ */
+export function reducePeek(prev: PeekState, parts: PeekMessageParts): PeekState {
+	const tail = parts.thinking ? peekTail(parts.thinking, MAX_PEEK_LINES) : prev.tail;
+	let phase = prev.phase;
+	if (parts.thinking && phase === "idle") phase = "thinking";
+	if (parts.text && phase === "thinking") phase = "done";
+	return { phase, tail };
+}
+
+/** Fresh peek state (no task running yet). */
+export function createPeekState(): PeekState {
+	return { phase: "idle", tail: "" };
+}
+
+/**
+ * Collect the running thinking text and answer text from an assistant
+ * message's content parts. Thinking arrives token-by-token, so re-calling
+ * this on every `message_update` yields the cumulative text.
+ */
+export function collectPeekParts(content: unknown): PeekMessageParts {
+	let thinking = "";
+	let text = "";
+	if (!Array.isArray(content)) return { thinking, text };
+	for (const rawPart of content) {
+		if (!rawPart || typeof rawPart !== "object") continue;
+		const part = rawPart as { type?: unknown; thinking?: unknown; text?: unknown };
+		if (part.type === "thinking") {
+			thinking += stringValue(part.thinking) ?? stringValue(part.text) ?? "";
+		} else if (part.type === "text") {
+			text += stringValue(part.text) ?? "";
+		}
+	}
+	return { thinking, text };
+}
+
+/**
+ * Extract the last non-empty logical lines of the thinking text, whitespace-
+ * normalized. NOT width-bounded: clipping to the terminal happens at render
+ * time in buildPeekLabel/clipTail, so wide terminals get to see more of it.
+ */
+export function peekTail(fullThinking: string, lineCount = 1): string {
+	if (!fullThinking) return "";
+	const count = normalizePeekLineCount(lineCount);
+	const lines: string[] = [];
+	let end = fullThinking.length;
+	while (end > 0 && lines.length < count) {
+		const start = fullThinking.lastIndexOf("\n", end - 1) + 1;
+		const line = fullThinking.slice(start, end).replace(/\s+/g, " ").trim();
+		if (line) lines.push(line);
+		end = start - 1;
+	}
+	return lines.reverse().join("\n");
+}
+
+/**
+ * Clip a tail string to `budget` visible columns, keeping the END (it is a
+ * tail view) and prefixing "…" when clipped. Walk backwards over complete
+ * graphemes so measurement is limited to the visible suffix.
+ */
+export function clipTail(text: string, budget: number): string {
+	if (!text || budget <= 0) return "";
+	const limit = budget - 1; // reserve one column for the ellipsis
+	let w = 0;
+	let end = text.length;
+	let clippedStart = end;
+	const segments = graphemeSegmenter.segment(text);
+	while (end > 0) {
+		const part = segments.containing(end - 1)!;
+		w += visibleWidth(part.segment);
+		if (w > budget) return "…" + text.slice(clippedStart);
+		end = part.index;
+		if (w <= limit) clippedStart = end;
+	}
+	return text;
+}
+
+/**
+ * Build the label Pi renders in its hidden-thinking block. `width` is a
+ * conservative budget that keeps each native Text row within the terminal.
+ * In two-line mode, an overflowing latest logical line uses both rows for
+ * its continuation instead of retaining the previous logical line.
+ */
+export function buildPeekLabel(
+	state: PeekState,
+	frame: number,
+	glyphs: IconGlyphs,
+	width: number,
+	lineCount = 1,
+): string {
+	const w = Math.max(1, Math.floor(width));
+	const prefix = `${glyphs.thinking} think`;
+	const count = normalizePeekLineCount(lineCount);
+	const fit = (line: string): string => truncateToWidth(line, w, "…");
+	switch (state.phase) {
+		case "thinking": {
+			const spin = SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? "";
+			// Thinking text is model output (untrusted): strip terminal control
+			// sequences before placing it in Pi's native label.
+			const marker = `${prefix} ${spin}`;
+			const markerWidth = visibleWidth(`${marker} `);
+			const contentWidth = Math.max(0, w - markerWidth);
+			const thoughtIndent = " ".repeat(markerWidth);
+			const safeLines = state.tail
+				.split("\n")
+				.map((tail) => sanitizeStatus(tail))
+				.filter(Boolean)
+				.slice(-count);
+			const latest = safeLines.at(-1) ?? "";
+			const lineWithMarker = (tail: string): string => fit(tail ? `${marker} ${tail}` : marker);
+			if (count >= 2) {
+				const window = clipTail(latest, contentWidth * count);
+				const latestWrapped = wrapTextWithAnsi(window, Math.max(1, contentWidth));
+				if (latestWrapped.length > 1) {
+					// Word wrapping may add short rows; always retain the newest content.
+					const first = latestWrapped.at(-2) ?? "";
+					const second = latestWrapped.at(-1) ?? "";
+					return `${lineWithMarker(first)}\n${fit(`${thoughtIndent}${second}`)}`;
+				}
+			}
+			const firstTail = clipTail(count >= 2 ? safeLines[0] ?? "" : latest, contentWidth);
+			if (count < 2 || safeLines.length < 2) return lineWithMarker(firstTail);
+			// Align the latest line with the first line's thinking text, not with
+			// the status marker.
+			const secondTail = clipTail(latest, contentWidth);
+			return `${lineWithMarker(firstTail)}\n${fit(secondTail ? `${thoughtIndent}${secondTail}` : thoughtIndent)}`;
+		}
+		case "done":
+			return fit(`${prefix} ${glyphs.done}`);
+		default:
+			return fit(`${prefix} ·`);
+	}
+}