@narumitw/pi-statusline 0.50.0 → 0.50.2

package/src/commands.ts

@@ -1,937 +1,878 @@
 import {
-	DynamicBorder,
-	type ExtensionAPI,
-	type ExtensionCommandContext,
-	type KeybindingsManager,
+  DynamicBorder,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type KeybindingsManager,
 } from "@earendil-works/pi-coding-agent";
-import {
-	Container,
-	Key,
-	matchesKey,
-	Text,
-	truncateToWidth,
-	wrapTextWithAnsi,
-} from "@earendil-works/pi-tui";
+import { Container, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
 import { completeStatuslineArguments } from "./command-contract.js";
 import {
-	INFORMATION_PROFILE_NAMES,
-	INFORMATION_PROFILES,
-	type InformationProfileName,
-	inferInformationProfile,
+  INFORMATION_PROFILE_NAMES,
+  INFORMATION_PROFILES,
+  type InformationProfileName,
+  inferInformationProfile,
 } from "./information-profiles.js";
 import { segmentPaletteForPreset } from "./presets/index.js";
 import {
-	DEFAULT_STATUSLINE_DOCUMENT,
-	type LoadedStatuslineSettings,
-	removeStatuslineSettingsDocumentIfMatches,
-	saveStatuslineSettingsDocument,
+  DEFAULT_STATUSLINE_DOCUMENT,
+  type LoadedStatuslineSettings,
+  removeStatuslineSettingsDocumentIfMatches,
+  saveStatuslineSettingsDocument,
 } from "./settings.js";
 import {
-	type ConfigSegmentName,
-	LINE_BREAK_SEGMENT_NAME,
-	PALETTE_NAMES,
-	PALETTE_PRESET_NAMES,
-	type PaletteName,
-	type PalettePreset,
-	SEGMENT_NAMES,
-	type SegmentName,
+  type ConfigSegmentName,
+  LINE_BREAK_SEGMENT_NAME,
+  PALETTE_NAMES,
+  PALETTE_PRESET_NAMES,
+  type PaletteName,
+  type PalettePreset,
+  SEGMENT_NAMES,
+  type SegmentName,
 } from "./types.js";
 
 const EDIT_SETTINGS_LABEL = "Edit settings JSON";
 const SEGMENT_VIEWPORT_SIZE = 6;
 const NARROW_SEGMENT_VIEWPORT_SIZE = 3;
 const SEGMENT_DESCRIPTIONS: Record<SegmentName, string> = {
-	brand: "Pi brand mark",
-	provider: "Current model provider",
-	model: "Current model name",
-	thinking: "Current thinking level",
-	cwd: "Current working directory",
-	branch: "Git branch, status, and linked pull request",
-	tools: "Current tool and streaming activity",
-	context: "Current context-window usage",
-	tokens: "Session token totals",
-	cache: "Prompt-cache reads, writes, and latest hit rate",
-	cost: "Session cost",
-	time: "Current local time",
-	turn: "Current session turn count",
+  brand: "Pi brand mark",
+  provider: "Current model provider",
+  model: "Current model name",
+  thinking: "Current thinking level",
+  cwd: "Current working directory",
+  branch: "Git branch, status, and linked pull request",
+  tools: "Current tool and streaming activity",
+  context: "Current context-window usage",
+  tokens: "Session token totals",
+  cache: "Prompt-cache reads, writes, and latest hit rate",
+  cost: "Session cost",
+  time: "Current local time",
+  turn: "Current session turn count",
 };
 interface StatuslineMenuOwner {
-	signal: AbortSignal;
-	isCurrent(): boolean;
+  signal: AbortSignal;
+  isCurrent(): boolean;
 }
 
 export interface StatuslineCommandOptions {
-	settingsPath: string;
-	getLoaded(): LoadedStatuslineSettings;
-	apply(loaded: LoadedStatuslineSettings, ctx: ExtensionCommandContext): void;
-	preview?(palettePreset: PalettePreset | undefined, ctx: ExtensionCommandContext): void;
-	save?: (settingsPath: string, rawDocument: string) => LoadedStatuslineSettings;
-	getMenuOwner?(): StatuslineMenuOwner;
+  settingsPath: string;
+  getLoaded(): LoadedStatuslineSettings;
+  apply(loaded: LoadedStatuslineSettings, ctx: ExtensionCommandContext): void;
+  preview?(palettePreset: PalettePreset | undefined, ctx: ExtensionCommandContext): void;
+  save?: (settingsPath: string, rawDocument: string) => LoadedStatuslineSettings;
+  getMenuOwner?(): StatuslineMenuOwner;
 }
 
 export function registerStatuslineCommand(pi: ExtensionAPI, options: StatuslineCommandOptions) {
-	pi.registerCommand("statusline", {
-		description: "Open or inspect the statusline settings",
-		getArgumentCompletions: completeStatuslineArguments,
-		handler: (args, ctx) => handleStatuslineCommand(args, ctx, options),
-	});
+  pi.registerCommand("statusline", {
+    description: "Open or inspect the statusline settings",
+    getArgumentCompletions: completeStatuslineArguments,
+    handler: (args, ctx) => handleStatuslineCommand(args, ctx, options),
+  });
 }
 
 export async function handleStatuslineCommand(
-	args: string,
-	ctx: ExtensionCommandContext,
-	options: StatuslineCommandOptions,
+  args: string,
+  ctx: ExtensionCommandContext,
+  options: StatuslineCommandOptions,
 ) {
-	const normalized = args.trim();
-	if (!normalized) {
-		await showMainMenu(ctx, options);
-		return;
-	}
-
-	const tokens = normalized.split(/\s+/u);
-	const subcommand = tokens[0]?.toLowerCase() ?? "";
-	if (tokens.length > 1) {
-		if (canNotify(ctx)) {
-			ctx.ui.notify(`/statusline ${subcommand} does not accept trailing arguments.`, "warning");
-		}
-		return;
-	}
-
-	switch (subcommand) {
-		case "settings":
-			await editSettings(ctx, options);
-			return;
-		case "status":
-			showStatus(ctx, options);
-			return;
-		case "help":
-			showHelp(ctx, options.settingsPath);
-			return;
-		default:
-			if (canNotify(ctx)) {
-				ctx.ui.notify(`Unknown /statusline subcommand: ${subcommand}`, "warning");
-			}
-	}
+  const normalized = args.trim();
+  if (!normalized) {
+    await showMainMenu(ctx, options);
+    return;
+  }
+
+  const tokens = normalized.split(/\s+/u);
+  const subcommand = tokens[0]?.toLowerCase() ?? "";
+  if (tokens.length > 1) {
+    if (canNotify(ctx)) {
+      ctx.ui.notify(`/statusline ${subcommand} does not accept trailing arguments.`, "warning");
+    }
+    return;
+  }
+
+  switch (subcommand) {
+    case "settings":
+      await editSettings(ctx, options);
+      return;
+    case "status":
+      showStatus(ctx, options);
+      return;
+    case "help":
+      showHelp(ctx, options.settingsPath);
+      return;
+    default:
+      if (canNotify(ctx)) {
+        ctx.ui.notify(`Unknown /statusline subcommand: ${subcommand}`, "warning");
+      }
+  }
 }
 
 async function showMainMenu(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
-	if (ctx.mode !== "tui") {
-		if (ctx.hasUI) ctx.ui.notify("/statusline requires an interactive Pi UI in TUI mode.", "error");
-		return;
-	}
-	const fallbackController = new AbortController();
-	const owner = options.getMenuOwner?.() ?? {
-		signal: fallbackController.signal,
-		isCurrent: () => !fallbackController.signal.aborted,
-	};
-	const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
-	if (owner.signal.aborted || !owner.isCurrent()) return;
-	type Screen = "main" | "advanced" | "information";
-	type Action = "appearance" | "setInformation" | "layout" | "edit" | "status" | "help" | "back";
-	const menu = defineMenu<undefined, Screen, Action, ExtensionCommandContext>({
-		start: "main",
-		screens: {
-			main: () => {
-				const config = options.getLoaded().config;
-				return {
-					kind: "actions",
-					title: "pi-statusline",
-					items: [
-						{
-							id: "appearance",
-							label: `Appearance (${config.palettePreset})`,
-							action: "appearance",
-						},
-						{
-							id: "information",
-							label: `Information (${inferInformationProfile(config.segments)})`,
-							to: "information",
-						},
-						{ id: "advanced", label: "Advanced", to: "advanced" },
-						{ id: "status", label: "Status", action: "status" },
-						{ id: "help", label: "Help", action: "help" },
-					],
-					hint: "close",
-				};
-			},
-			information: () => {
-				const current = inferInformationProfile(options.getLoaded().config.segments);
-				return {
-					kind: "choice",
-					title: "Information level",
-					lines: [`Current profile: ${current}`],
-					items: INFORMATION_PROFILE_NAMES.map((profile) => ({
-						id: profile,
-						label: `${profile[0]?.toUpperCase() ?? ""}${profile.slice(1)}`,
-						description: `${INFORMATION_PROFILES[profile].length} segments`,
-						details: [`Segments: ${INFORMATION_PROFILES[profile].join(" · ")}`],
-					})),
-					action: "setInformation",
-					currentItemId: current,
-					initialItemId: current === "custom" ? "balanced" : current,
-					hint: "close",
-				};
-			},
-			advanced: () => {
-				const config = options.getLoaded().config;
-				const visibleSegmentCount = config.segments.filter(
-					(segment): segment is SegmentName => segment !== LINE_BREAK_SEGMENT_NAME,
-				).length;
-				return {
-					kind: "actions",
-					title: "pi-statusline — Advanced",
-					items: [
-						{
-							id: "layout",
-							label: `Custom layout (${visibleSegmentCount}/${SEGMENT_NAMES.length} shown)`,
-							action: "layout",
-						},
-						{ id: "edit", label: EDIT_SETTINGS_LABEL, action: "edit" },
-						{ id: "back", label: "Back", action: "back" },
-					],
-					hint: "back",
-				};
-			},
-		},
-		actions: {
-			appearance: async () => {
-				await choosePalettePreset(ctx, options, owner);
-				return { kind: "close" };
-			},
-			setInformation: async ({ itemId }) => {
-				const profile = INFORMATION_PROFILE_NAMES.find((candidate) => candidate === itemId);
-				if (!profile) return { kind: "rejected" };
-				applyInformationProfile(ctx, options, profile);
-				return { kind: "close" };
-			},
-			layout: async () => {
-				await chooseSegments(ctx, options);
-				return { kind: "close" };
-			},
-			edit: async () => {
-				await editSettings(ctx, options);
-				return { kind: "close" };
-			},
-			status: async () => {
-				showStatus(ctx, options);
-				return { kind: "close" };
-			},
-			help: async () => {
-				showHelp(ctx, options.settingsPath);
-				return { kind: "close" };
-			},
-			back: async () => ({ kind: "back" }),
-		},
-	});
-	try {
-		await runMenu(ctx, menu, {
-			getState: () => undefined,
-			signal: owner.signal,
-			isCurrent: owner.isCurrent,
-		});
-	} finally {
-		fallbackController.abort(new DOMException("Statusline menu closed", "AbortError"));
-	}
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify("/statusline requires an interactive Pi UI in TUI mode.", "error");
+    return;
+  }
+  const fallbackController = new AbortController();
+  const owner = options.getMenuOwner?.() ?? {
+    signal: fallbackController.signal,
+    isCurrent: () => !fallbackController.signal.aborted,
+  };
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (owner.signal.aborted || !owner.isCurrent()) return;
+  type Screen = "main" | "advanced" | "information";
+  type Action = "appearance" | "setInformation" | "layout" | "edit" | "status" | "help" | "back";
+  const menu = defineMenu<undefined, Screen, Action, ExtensionCommandContext>({
+    start: "main",
+    screens: {
+      main: () => {
+        const config = options.getLoaded().config;
+        return {
+          kind: "actions",
+          title: "pi-statusline",
+          items: [
+            {
+              id: "appearance",
+              label: `Appearance (${config.palettePreset})`,
+              action: "appearance",
+            },
+            {
+              id: "information",
+              label: `Information (${inferInformationProfile(config.segments)})`,
+              to: "information",
+            },
+            { id: "advanced", label: "Advanced", to: "advanced" },
+            { id: "status", label: "Status", action: "status" },
+            { id: "help", label: "Help", action: "help" },
+          ],
+          hint: "close",
+        };
+      },
+      information: () => {
+        const current = inferInformationProfile(options.getLoaded().config.segments);
+        return {
+          kind: "choice",
+          title: "Information level",
+          lines: [`Current profile: ${current}`],
+          items: INFORMATION_PROFILE_NAMES.map((profile) => ({
+            id: profile,
+            label: `${profile[0]?.toUpperCase() ?? ""}${profile.slice(1)}`,
+            description: `${INFORMATION_PROFILES[profile].length} segments`,
+            details: [`Segments: ${INFORMATION_PROFILES[profile].join(" · ")}`],
+          })),
+          action: "setInformation",
+          currentItemId: current,
+          initialItemId: current === "custom" ? "balanced" : current,
+          hint: "close",
+        };
+      },
+      advanced: () => {
+        const config = options.getLoaded().config;
+        const visibleSegmentCount = config.segments.filter(
+          (segment): segment is SegmentName => segment !== LINE_BREAK_SEGMENT_NAME,
+        ).length;
+        return {
+          kind: "actions",
+          title: "pi-statusline — Advanced",
+          items: [
+            {
+              id: "layout",
+              label: `Custom layout (${visibleSegmentCount}/${SEGMENT_NAMES.length} shown)`,
+              action: "layout",
+            },
+            { id: "edit", label: EDIT_SETTINGS_LABEL, action: "edit" },
+            { id: "back", label: "Back", action: "back" },
+          ],
+          hint: "back",
+        };
+      },
+    },
+    actions: {
+      appearance: async () => {
+        await choosePalettePreset(ctx, options, owner);
+        return { kind: "close" };
+      },
+      setInformation: async ({ itemId }) => {
+        const profile = INFORMATION_PROFILE_NAMES.find((candidate) => candidate === itemId);
+        if (!profile) return { kind: "rejected" };
+        applyInformationProfile(ctx, options, profile);
+        return { kind: "close" };
+      },
+      layout: async () => {
+        await chooseSegments(ctx, options);
+        return { kind: "close" };
+      },
+      edit: async () => {
+        await editSettings(ctx, options);
+        return { kind: "close" };
+      },
+      status: async () => {
+        showStatus(ctx, options);
+        return { kind: "close" };
+      },
+      help: async () => {
+        showHelp(ctx, options.settingsPath);
+        return { kind: "close" };
+      },
+      back: async () => ({ kind: "back" }),
+    },
+  });
+  try {
+    await runMenu(ctx, menu, {
+      getState: () => undefined,
+      signal: owner.signal,
+      isCurrent: owner.isCurrent,
+    });
+  } finally {
+    fallbackController.abort(new DOMException("Statusline menu closed", "AbortError"));
+  }
 }
 
 async function choosePalettePreset(
-	ctx: ExtensionCommandContext,
-	options: StatuslineCommandOptions,
-	owner: StatuslineMenuOwner,
+  ctx: ExtensionCommandContext,
+  options: StatuslineCommandOptions,
+  owner: StatuslineMenuOwner,
 ) {
-	if (ctx.mode !== "tui") {
-		if (ctx.hasUI) ctx.ui.notify(`Edit palettePreset manually: ${options.settingsPath}`, "info");
-		return;
-	}
-	const current = options.getLoaded();
-	let selection: PalettePreset | undefined;
-	try {
-		selection = await showPalettePresetPicker(ctx, current.config.palettePreset, options, owner);
-	} finally {
-		if (!owner.signal.aborted && owner.isCurrent()) {
-			try {
-				options.preview?.(undefined, ctx);
-			} catch (error) {
-				if (canNotify(ctx)) {
-					ctx.ui.notify(`Palette preview could not be reset: ${formatError(error)}`, "error");
-				}
-			}
-		}
-	}
-	if (owner.signal.aborted || !owner.isCurrent()) return;
-	if (selection === undefined) return;
-
-	let loaded: LoadedStatuslineSettings;
-	try {
-		const rawDocument = palettePresetDocument(current, selection);
-		loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, rawDocument);
-	} catch (error) {
-		ctx.ui.notify(`Palette preset was not saved: ${formatError(error)}`, "error");
-		return;
-	}
-	try {
-		options.apply(loaded, ctx);
-	} catch (error) {
-		const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
-		ctx.ui.notify(
-			rollbackError
-				? `Palette preset could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}`
-				: `Palette preset could not be applied: ${formatError(error)}; previous settings restored.`,
-			"error",
-		);
-		return;
-	}
-	const message =
-		loaded.config.palettePreset === "custom"
-			? "Custom palette applied. Edit colors via /statusline → Advanced → Edit settings JSON."
-			: `Palette preset applied: ${loaded.config.palettePreset}.`;
-	ctx.ui.notify(message, "info");
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit palettePreset manually: ${options.settingsPath}`, "info");
+    return;
+  }
+  const current = options.getLoaded();
+  let selection: PalettePreset | undefined;
+  try {
+    selection = await showPalettePresetPicker(ctx, current.config.palettePreset, options, owner);
+  } finally {
+    if (!owner.signal.aborted && owner.isCurrent()) {
+      try {
+        options.preview?.(undefined, ctx);
+      } catch (error) {
+        if (canNotify(ctx)) {
+          ctx.ui.notify(`Palette preview could not be reset: ${formatError(error)}`, "error");
+        }
+      }
+    }
+  }
+  if (owner.signal.aborted || !owner.isCurrent()) return;
+  if (selection === undefined) return;
+
+  let loaded: LoadedStatuslineSettings;
+  try {
+    const rawDocument = palettePresetDocument(current, selection);
+    loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, rawDocument);
+  } catch (error) {
+    ctx.ui.notify(`Palette preset was not saved: ${formatError(error)}`, "error");
+    return;
+  }
+  try {
+    options.apply(loaded, ctx);
+  } catch (error) {
+    const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
+    ctx.ui.notify(
+      rollbackError
+        ? `Palette preset could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}`
+        : `Palette preset could not be applied: ${formatError(error)}; previous settings restored.`,
+      "error",
+    );
+    return;
+  }
+  const message =
+    loaded.config.palettePreset === "custom"
+      ? "Custom palette applied. Edit colors via /statusline → Advanced → Edit settings JSON."
+      : `Palette preset applied: ${loaded.config.palettePreset}.`;
+  ctx.ui.notify(message, "info");
 }
 
 async function showPalettePresetPicker(
-	ctx: ExtensionCommandContext,
-	current: PalettePreset,
-	options: StatuslineCommandOptions,
-	owner: StatuslineMenuOwner,
+  ctx: ExtensionCommandContext,
+  current: PalettePreset,
+  options: StatuslineCommandOptions,
+  owner: StatuslineMenuOwner,
 ): Promise<PalettePreset | undefined> {
-	const { runLiveChoice } = await import("@narumitw/pi-tui-kit");
-	const result = await runLiveChoice(ctx, {
-		title: `Palette preset (current: ${current})`,
-		items: PALETTE_PRESET_NAMES.map((palettePreset) => ({
-			id: palettePreset,
-			label: palettePreset,
-			description: palettePreset === "custom" ? "per-segment colors from settings JSON" : undefined,
-		})),
-		currentItemId: current,
-		initialItemId: current,
-		viewportSize: Math.min(PALETTE_PRESET_NAMES.length, 10),
-		hint: "close",
-		navigationLabel: "preview",
-		confirmLabel: "apply",
-		onSelectionChange: ({ item }) => options.preview?.(item.id, ctx),
-		signal: owner.signal,
-		isCurrent: owner.isCurrent,
-	});
-	return result.kind === "selected" ? result.itemId : undefined;
+  const { runLiveChoice } = await import("@narumitw/pi-tui-kit");
+  const result = await runLiveChoice(ctx, {
+    title: `Palette preset (current: ${current})`,
+    items: PALETTE_PRESET_NAMES.map((palettePreset) => ({
+      id: palettePreset,
+      label: palettePreset,
+      description: palettePreset === "custom" ? "per-segment colors from settings JSON" : undefined,
+    })),
+    currentItemId: current,
+    initialItemId: current,
+    viewportSize: Math.min(PALETTE_PRESET_NAMES.length, 10),
+    hint: "close",
+    navigationLabel: "preview",
+    confirmLabel: "apply",
+    onSelectionChange: ({ item }) => options.preview?.(item.id, ctx),
+    signal: owner.signal,
+    isCurrent: owner.isCurrent,
+  });
+  return result.kind === "selected" ? result.itemId : undefined;
 }
 
 function applyInformationProfile(
-	ctx: ExtensionCommandContext,
-	options: StatuslineCommandOptions,
-	selection: InformationProfileName,
+  ctx: ExtensionCommandContext,
+  options: StatuslineCommandOptions,
+  selection: InformationProfileName,
 ) {
-	const current = options.getLoaded();
-	try {
-		const change = informationProfileDocument(current, selection);
-		const loaded = applySegmentsDocumentChange(change, ctx, options);
-		ctx.ui.notify(
-			`Information level applied: ${inferInformationProfile(loaded.config.segments)}.`,
-			"info",
-		);
-	} catch (error) {
-		ctx.ui.notify(`Information level was not saved: ${formatError(error)}`, "error");
-	}
+  const current = options.getLoaded();
+  try {
+    const change = informationProfileDocument(current, selection);
+    const loaded = applySegmentsDocumentChange(change, ctx, options);
+    ctx.ui.notify(`Information level applied: ${inferInformationProfile(loaded.config.segments)}.`, "info");
+  } catch (error) {
+    ctx.ui.notify(`Information level was not saved: ${formatError(error)}`, "error");
+  }
 }
 
 async function chooseSegments(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
-	if (ctx.mode !== "tui") {
-		if (ctx.hasUI) ctx.ui.notify(`Edit segments manually: ${options.settingsPath}`, "info");
-		return;
-	}
-	let current = options.getLoaded();
-	let names = segmentMenuOrder(current);
-	let selectedIndex = 0;
-	let moveMode = false;
-	let feedback: string | undefined;
-
-	await ctx.ui.custom((tui, theme, keybindings, done) => {
-		const commit = (
-			name: SegmentName,
-			change: { nextDocument: string; previousDocument: string },
-		): boolean => {
-			try {
-				current = applySegmentsDocumentChange(change, ctx, options);
-				names = segmentMenuOrder(current);
-				selectedIndex = Math.max(0, names.indexOf(name));
-				feedback = undefined;
-				return true;
-			} catch (error) {
-				ctx.ui.notify(`Statusline segments were not saved: ${formatError(error)}`, "error");
-				return false;
-			}
-		};
-
-		const toggleSelected = () => {
-			const name = names[selectedIndex];
-			if (!name) return;
-			moveMode = false;
-			commit(name, segmentsDocument(current, name, !current.config.segments.includes(name)));
-		};
-
-		const toggleLineBreakAfterSelected = () => {
-			const name = names[selectedIndex];
-			if (!name) return;
-			moveMode = false;
-			const segmentIndex = current.config.segments.indexOf(name);
-			if (segmentIndex < 0) {
-				feedback = `Show ${name} before adding a line break.`;
-				return;
-			}
-			const hasLineBreak = current.config.segments[segmentIndex + 1] === LINE_BREAK_SEGMENT_NAME;
-			const hasFollowingSegment = current.config.segments
-				.slice(segmentIndex + 1)
-				.some((segment) => segment !== LINE_BREAK_SEGMENT_NAME);
-			if (!hasLineBreak && !hasFollowingSegment) {
-				feedback = `Add another visible segment after ${name} before adding a line break.`;
-				return;
-			}
-			commit(name, lineBreakAfterDocument(current, name));
-		};
-
-		const reorderSelected = (direction: -1 | 1) => {
-			const name = names[selectedIndex];
-			if (!name) return;
-			const visibleNames = visibleSegmentNames(current);
-			const currentIndex = visibleNames.indexOf(name);
-			if (currentIndex < 0) {
-				feedback = `Show ${name} before moving it.`;
-				return;
-			}
-			const targetIndex = currentIndex + direction;
-			if (targetIndex < 0 || targetIndex >= visibleNames.length) {
-				feedback = `${name} is already the ${direction < 0 ? "first" : "last"} visible segment.`;
-				return;
-			}
-			const change = reorderedSegmentsDocument(current, name, direction);
-			if (change) commit(name, change);
-		};
-
-		const enterMoveMode = () => {
-			const name = names[selectedIndex];
-			if (!name) return;
-			if (!current.config.segments.includes(name)) {
-				feedback = `Show ${name} before moving it.`;
-				return;
-			}
-			moveMode = true;
-			feedback = undefined;
-		};
-
-		const moveSelection = (offset: number) => {
-			selectedIndex = Math.max(0, Math.min(names.length - 1, selectedIndex + offset));
-			feedback = undefined;
-		};
-
-		const renderList = (width: number): string[] => {
-			const safeWidth = Math.max(1, width);
-			const visibleNames = visibleSegmentNames(current);
-			const visible = new Set(visibleNames);
-			const placements = segmentPlacements(current.config.segments);
-			const viewportSize = safeWidth < 30 ? NARROW_SEGMENT_VIEWPORT_SIZE : SEGMENT_VIEWPORT_SIZE;
-			const startIndex = Math.max(
-				0,
-				Math.min(
-					selectedIndex - Math.floor(viewportSize / 2),
-					Math.max(0, names.length - viewportSize),
-				),
-			);
-			const endIndex = Math.min(names.length, startIndex + viewportSize);
-			const lines: string[] = [];
-			let previousSection: "visible" | "hidden" | undefined;
-			for (let index = startIndex; index < endIndex; index += 1) {
-				const name = names[index];
-				if (!name) continue;
-				const section = visible.has(name) ? "visible" : "hidden";
-				if (section !== previousSection) {
-					const heading =
-						section === "visible" ? "Visible — render order" : "Hidden — not rendered";
-					lines.push(theme.fg("muted", theme.bold(truncateToWidth(`  ${heading}`, safeWidth))));
-					previousSection = section;
-				}
-				const isSelected = index === selectedIndex;
-				const prefix = isSelected ? "→ " : "  ";
-				const placement = placements.get(name);
-				const lineBreakLabel = hasLineBreakAfter(current.config.segments, name)
-					? " · break after"
-					: "";
-				const row = placement
-					? `${prefix}${`${placement.order}.`.padStart(3)} row ${placement.row} · ${name.padEnd(8)} · visible${lineBreakLabel}`
-					: `${prefix}  · ${name.padEnd(8)} · hidden`;
-				const truncated = truncateToWidth(row, safeWidth);
-				if (isSelected) lines.push(theme.fg("accent", truncated));
-				else lines.push(section === "visible" ? truncated : theme.fg("muted", truncated));
-			}
-			if (startIndex > 0 || endIndex < names.length) {
-				lines.push(
-					theme.fg(
-						"dim",
-						truncateToWidth(`  (${startIndex + 1}-${endIndex}/${names.length})`, safeWidth),
-					),
-				);
-			}
-
-			const selected = names[selectedIndex];
-			if (selected) {
-				lines.push("");
-				const detail = feedback ?? SEGMENT_DESCRIPTIONS[selected];
-				const color = feedback ? "warning" : "muted";
-				for (const line of wrapTextWithAnsi(detail, Math.max(1, safeWidth - 2))) {
-					lines.push(theme.fg(color, truncateToWidth(`  ${line}`, safeWidth)));
-				}
-			}
-
-			lines.push("");
-			const hints = segmentControlHints(safeWidth, moveMode, selected, keybindings);
-			for (const hint of hints) {
-				lines.push(theme.fg("dim", truncateToWidth(`  ${hint}`, safeWidth)));
-			}
-			return lines;
-		};
-
-		const container = new Container();
-		container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-		const title = new Text("", 1, 0);
-		container.addChild(title);
-		container.addChild({ render: renderList, invalidate() {} });
-		container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-		const updateThemedText = () => {
-			title.setText(theme.fg("accent", theme.bold("Statusline segments")));
-		};
-		updateThemedText();
-
-		return {
-			render: (width: number) => container.render(width),
-			invalidate() {
-				container.invalidate();
-				updateThemedText();
-			},
-			handleInput(data: string) {
-				if (matchesKey(data, Key.ctrl("c"))) {
-					done(undefined);
-					return;
-				}
-				const moveModeKey = matchesKey(data, "m") || matchesKey(data, Key.shift("m"));
-				const lineBreakKey = matchesKey(data, "b") || matchesKey(data, Key.shift("b"));
-				if (matchesKey(data, Key.alt("up"))) {
-					reorderSelected(-1);
-				} else if (matchesKey(data, Key.alt("down"))) {
-					reorderSelected(1);
-				} else if (moveMode) {
-					if (keybindings.matches(data, "tui.select.up")) {
-						reorderSelected(-1);
-					} else if (keybindings.matches(data, "tui.select.down")) {
-						reorderSelected(1);
-					} else if (
-						moveModeKey ||
-						keybindings.matches(data, "tui.select.confirm") ||
-						data === " " ||
-						keybindings.matches(data, "tui.select.cancel")
-					) {
-						moveMode = false;
-						feedback = undefined;
-					}
-				} else if (keybindings.matches(data, "tui.select.up")) {
-					selectedIndex = selectedIndex === 0 ? names.length - 1 : selectedIndex - 1;
-					feedback = undefined;
-				} else if (keybindings.matches(data, "tui.select.down")) {
-					selectedIndex = selectedIndex === names.length - 1 ? 0 : selectedIndex + 1;
-					feedback = undefined;
-				} else if (keybindings.matches(data, "tui.select.pageUp")) {
-					moveSelection(-SEGMENT_VIEWPORT_SIZE);
-				} else if (keybindings.matches(data, "tui.select.pageDown")) {
-					moveSelection(SEGMENT_VIEWPORT_SIZE);
-				} else if (moveModeKey) {
-					enterMoveMode();
-				} else if (lineBreakKey) {
-					toggleLineBreakAfterSelected();
-				} else if (keybindings.matches(data, "tui.select.confirm") || data === " ") {
-					toggleSelected();
-				} else if (keybindings.matches(data, "tui.select.cancel")) {
-					done(undefined);
-				}
-				tui.requestRender();
-			},
-		};
-	});
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit segments manually: ${options.settingsPath}`, "info");
+    return;
+  }
+  let current = options.getLoaded();
+  let names = segmentMenuOrder(current);
+  let selectedIndex = 0;
+  let moveMode = false;
+  let feedback: string | undefined;
+
+  await ctx.ui.custom((tui, theme, keybindings, done) => {
+    const commit = (name: SegmentName, change: { nextDocument: string; previousDocument: string }): boolean => {
+      try {
+        current = applySegmentsDocumentChange(change, ctx, options);
+        names = segmentMenuOrder(current);
+        selectedIndex = Math.max(0, names.indexOf(name));
+        feedback = undefined;
+        return true;
+      } catch (error) {
+        ctx.ui.notify(`Statusline segments were not saved: ${formatError(error)}`, "error");
+        return false;
+      }
+    };
+
+    const toggleSelected = () => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      moveMode = false;
+      commit(name, segmentsDocument(current, name, !current.config.segments.includes(name)));
+    };
+
+    const toggleLineBreakAfterSelected = () => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      moveMode = false;
+      const segmentIndex = current.config.segments.indexOf(name);
+      if (segmentIndex < 0) {
+        feedback = `Show ${name} before adding a line break.`;
+        return;
+      }
+      const hasLineBreak = current.config.segments[segmentIndex + 1] === LINE_BREAK_SEGMENT_NAME;
+      const hasFollowingSegment = current.config.segments
+        .slice(segmentIndex + 1)
+        .some((segment) => segment !== LINE_BREAK_SEGMENT_NAME);
+      if (!hasLineBreak && !hasFollowingSegment) {
+        feedback = `Add another visible segment after ${name} before adding a line break.`;
+        return;
+      }
+      commit(name, lineBreakAfterDocument(current, name));
+    };
+
+    const reorderSelected = (direction: -1 | 1) => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      const visibleNames = visibleSegmentNames(current);
+      const currentIndex = visibleNames.indexOf(name);
+      if (currentIndex < 0) {
+        feedback = `Show ${name} before moving it.`;
+        return;
+      }
+      const targetIndex = currentIndex + direction;
+      if (targetIndex < 0 || targetIndex >= visibleNames.length) {
+        feedback = `${name} is already the ${direction < 0 ? "first" : "last"} visible segment.`;
+        return;
+      }
+      const change = reorderedSegmentsDocument(current, name, direction);
+      if (change) commit(name, change);
+    };
+
+    const enterMoveMode = () => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      if (!current.config.segments.includes(name)) {
+        feedback = `Show ${name} before moving it.`;
+        return;
+      }
+      moveMode = true;
+      feedback = undefined;
+    };
+
+    const moveSelection = (offset: number) => {
+      selectedIndex = Math.max(0, Math.min(names.length - 1, selectedIndex + offset));
+      feedback = undefined;
+    };
+
+    const renderList = (width: number): string[] => {
+      const safeWidth = Math.max(1, width);
+      const visibleNames = visibleSegmentNames(current);
+      const visible = new Set(visibleNames);
+      const placements = segmentPlacements(current.config.segments);
+      const viewportSize = safeWidth < 30 ? NARROW_SEGMENT_VIEWPORT_SIZE : SEGMENT_VIEWPORT_SIZE;
+      const startIndex = Math.max(
+        0,
+        Math.min(selectedIndex - Math.floor(viewportSize / 2), Math.max(0, names.length - viewportSize)),
+      );
+      const endIndex = Math.min(names.length, startIndex + viewportSize);
+      const lines: string[] = [];
+      let previousSection: "visible" | "hidden" | undefined;
+      for (let index = startIndex; index < endIndex; index += 1) {
+        const name = names[index];
+        if (!name) continue;
+        const section = visible.has(name) ? "visible" : "hidden";
+        if (section !== previousSection) {
+          const heading = section === "visible" ? "Visible — render order" : "Hidden — not rendered";
+          lines.push(theme.fg("muted", theme.bold(truncateToWidth(`  ${heading}`, safeWidth))));
+          previousSection = section;
+        }
+        const isSelected = index === selectedIndex;
+        const prefix = isSelected ? "→ " : "  ";
+        const placement = placements.get(name);
+        const lineBreakLabel = hasLineBreakAfter(current.config.segments, name) ? " · break after" : "";
+        const row = placement
+          ? `${prefix}${`${placement.order}.`.padStart(3)} row ${placement.row} · ${name.padEnd(8)} · visible${lineBreakLabel}`
+          : `${prefix}  · ${name.padEnd(8)} · hidden`;
+        const truncated = truncateToWidth(row, safeWidth);
+        if (isSelected) lines.push(theme.fg("accent", truncated));
+        else lines.push(section === "visible" ? truncated : theme.fg("muted", truncated));
+      }
+      if (startIndex > 0 || endIndex < names.length) {
+        lines.push(theme.fg("dim", truncateToWidth(`  (${startIndex + 1}-${endIndex}/${names.length})`, safeWidth)));
+      }
+
+      const selected = names[selectedIndex];
+      if (selected) {
+        lines.push("");
+        const detail = feedback ?? SEGMENT_DESCRIPTIONS[selected];
+        const color = feedback ? "warning" : "muted";
+        for (const line of wrapTextWithAnsi(detail, Math.max(1, safeWidth - 2))) {
+          lines.push(theme.fg(color, truncateToWidth(`  ${line}`, safeWidth)));
+        }
+      }
+
+      lines.push("");
+      const hints = segmentControlHints(safeWidth, moveMode, selected, keybindings);
+      for (const hint of hints) {
+        lines.push(theme.fg("dim", truncateToWidth(`  ${hint}`, safeWidth)));
+      }
+      return lines;
+    };
+
+    const container = new Container();
+    container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+    const title = new Text("", 1, 0);
+    container.addChild(title);
+    container.addChild({ render: renderList, invalidate() {} });
+    container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+    const updateThemedText = () => {
+      title.setText(theme.fg("accent", theme.bold("Statusline segments")));
+    };
+    updateThemedText();
+
+    return {
+      render: (width: number) => container.render(width),
+      invalidate() {
+        container.invalidate();
+        updateThemedText();
+      },
+      handleInput(data: string) {
+        if (matchesKey(data, Key.ctrl("c"))) {
+          done(undefined);
+          return;
+        }
+        const moveModeKey = matchesKey(data, "m") || matchesKey(data, Key.shift("m"));
+        const lineBreakKey = matchesKey(data, "b") || matchesKey(data, Key.shift("b"));
+        if (matchesKey(data, Key.alt("up"))) {
+          reorderSelected(-1);
+        } else if (matchesKey(data, Key.alt("down"))) {
+          reorderSelected(1);
+        } else if (moveMode) {
+          if (keybindings.matches(data, "tui.select.up")) {
+            reorderSelected(-1);
+          } else if (keybindings.matches(data, "tui.select.down")) {
+            reorderSelected(1);
+          } else if (
+            moveModeKey ||
+            keybindings.matches(data, "tui.select.confirm") ||
+            data === " " ||
+            keybindings.matches(data, "tui.select.cancel")
+          ) {
+            moveMode = false;
+            feedback = undefined;
+          }
+        } else if (keybindings.matches(data, "tui.select.up")) {
+          selectedIndex = selectedIndex === 0 ? names.length - 1 : selectedIndex - 1;
+          feedback = undefined;
+        } else if (keybindings.matches(data, "tui.select.down")) {
+          selectedIndex = selectedIndex === names.length - 1 ? 0 : selectedIndex + 1;
+          feedback = undefined;
+        } else if (keybindings.matches(data, "tui.select.pageUp")) {
+          moveSelection(-SEGMENT_VIEWPORT_SIZE);
+        } else if (keybindings.matches(data, "tui.select.pageDown")) {
+          moveSelection(SEGMENT_VIEWPORT_SIZE);
+        } else if (moveModeKey) {
+          enterMoveMode();
+        } else if (lineBreakKey) {
+          toggleLineBreakAfterSelected();
+        } else if (keybindings.matches(data, "tui.select.confirm") || data === " ") {
+          toggleSelected();
+        } else if (keybindings.matches(data, "tui.select.cancel")) {
+          done(undefined);
+        }
+        tui.requestRender();
+      },
+    };
+  });
 }
 
 async function editSettings(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
-	if (ctx.mode !== "tui") {
-		if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${options.settingsPath}`, "info");
-		return;
-	}
-	const current = options.getLoaded();
-	const edited = await ctx.ui.editor(
-		"pi-statusline.json — save and close to apply",
-		current.rawDocument ?? DEFAULT_STATUSLINE_DOCUMENT,
-	);
-	if (edited === undefined) return;
-	let loaded: LoadedStatuslineSettings;
-	try {
-		loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, edited);
-	} catch (error) {
-		ctx.ui.notify(`pi-statusline settings were not saved: ${formatError(error)}`, "error");
-		return;
-	}
-	try {
-		options.apply(loaded, ctx);
-	} catch (error) {
-		const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
-		ctx.ui.notify(
-			rollbackError
-				? `pi-statusline settings could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}`
-				: `pi-statusline settings could not be applied: ${formatError(error)}; previous settings restored.`,
-			"error",
-		);
-		return;
-	}
-	const suffix =
-		loaded.diagnostics.length > 0
-			? ` (${loaded.diagnostics.length} warning${loaded.diagnostics.length === 1 ? "" : "s"})`
-			: "";
-	ctx.ui.notify(`pi-statusline settings saved and applied${suffix}.`, "info");
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${options.settingsPath}`, "info");
+    return;
+  }
+  const current = options.getLoaded();
+  const edited = await ctx.ui.editor(
+    "pi-statusline.json — save and close to apply",
+    current.rawDocument ?? DEFAULT_STATUSLINE_DOCUMENT,
+  );
+  if (edited === undefined) return;
+  let loaded: LoadedStatuslineSettings;
+  try {
+    loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, edited);
+  } catch (error) {
+    ctx.ui.notify(`pi-statusline settings were not saved: ${formatError(error)}`, "error");
+    return;
+  }
+  try {
+    options.apply(loaded, ctx);
+  } catch (error) {
+    const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
+    ctx.ui.notify(
+      rollbackError
+        ? `pi-statusline settings could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}`
+        : `pi-statusline settings could not be applied: ${formatError(error)}; previous settings restored.`,
+      "error",
+    );
+    return;
+  }
+  const suffix =
+    loaded.diagnostics.length > 0
+      ? ` (${loaded.diagnostics.length} warning${loaded.diagnostics.length === 1 ? "" : "s"})`
+      : "";
+  ctx.ui.notify(`pi-statusline settings saved and applied${suffix}.`, "info");
 }
 
-function palettePresetDocument(
-	current: LoadedStatuslineSettings,
-	palettePreset: PalettePreset,
-): string {
-	const { parsed } = editableSettings(current, "choosing a palette preset");
-	if (palettePreset === "custom" && !isRecord(parsed.palette)) {
-		const seedPreset = isPaletteName(current.config.palettePreset)
-			? current.config.palettePreset
-			: "tokyo-night";
-		parsed.palette = segmentPaletteForPreset(seedPreset);
-	} else if (palettePreset !== "custom" && typeof parsed.palette === "string") {
-		delete parsed.palette;
-	}
-	parsed.palettePreset = palettePreset;
-	return `${JSON.stringify(parsed, null, "\t")}\n`;
+function palettePresetDocument(current: LoadedStatuslineSettings, palettePreset: PalettePreset): string {
+  const { parsed } = editableSettings(current, "choosing a palette preset");
+  if (palettePreset === "custom" && !isRecord(parsed.palette)) {
+    const seedPreset = isPaletteName(current.config.palettePreset) ? current.config.palettePreset : "tokyo-night";
+    parsed.palette = segmentPaletteForPreset(seedPreset);
+  } else if (palettePreset !== "custom" && typeof parsed.palette === "string") {
+    delete parsed.palette;
+  }
+  parsed.palettePreset = palettePreset;
+  return `${JSON.stringify(parsed, null, "\t")}\n`;
 }
 
 function informationProfileDocument(
-	current: LoadedStatuslineSettings,
-	profile: InformationProfileName,
+  current: LoadedStatuslineSettings,
+  profile: InformationProfileName,
 ): { nextDocument: string; previousDocument: string } {
-	const { parsed, rawDocument: previousDocument } = editableSettings(
-		current,
-		"changing information level",
-	);
-	parsed.segments = [...INFORMATION_PROFILES[profile]];
-	return {
-		nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
-		previousDocument,
-	};
+  const { parsed, rawDocument: previousDocument } = editableSettings(current, "changing information level");
+  parsed.segments = [...INFORMATION_PROFILES[profile]];
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
+    previousDocument,
+  };
 }
 
 function visibleSegmentNames(current: LoadedStatuslineSettings): SegmentName[] {
-	return current.config.segments.filter(
-		(segment): segment is SegmentName => segment !== LINE_BREAK_SEGMENT_NAME,
-	);
+  return current.config.segments.filter((segment): segment is SegmentName => segment !== LINE_BREAK_SEGMENT_NAME);
 }
 
 function segmentMenuOrder(current: LoadedStatuslineSettings): SegmentName[] {
-	const visible = visibleSegmentNames(current);
-	const visibleSet = new Set(visible);
-	return [...visible, ...SEGMENT_NAMES.filter((name) => !visibleSet.has(name))];
+  const visible = visibleSegmentNames(current);
+  const visibleSet = new Set(visible);
+  return [...visible, ...SEGMENT_NAMES.filter((name) => !visibleSet.has(name))];
 }
 
 function hasLineBreakAfter(segments: readonly ConfigSegmentName[], name: SegmentName): boolean {
-	const index = segments.indexOf(name);
-	return index >= 0 && segments[index + 1] === LINE_BREAK_SEGMENT_NAME;
+  const index = segments.indexOf(name);
+  return index >= 0 && segments[index + 1] === LINE_BREAK_SEGMENT_NAME;
 }
 
-function segmentPlacements(
-	segments: readonly ConfigSegmentName[],
-): Map<SegmentName, { order: number; row: number }> {
-	const placements = new Map<SegmentName, { order: number; row: number }>();
-	let order = 0;
-	let row = 1;
-	for (const segment of segments) {
-		if (segment === LINE_BREAK_SEGMENT_NAME) {
-			row += 1;
-			continue;
-		}
-		placements.set(segment, { order: ++order, row });
-	}
-	return placements;
+function segmentPlacements(segments: readonly ConfigSegmentName[]): Map<SegmentName, { order: number; row: number }> {
+  const placements = new Map<SegmentName, { order: number; row: number }>();
+  let order = 0;
+  let row = 1;
+  for (const segment of segments) {
+    if (segment === LINE_BREAK_SEGMENT_NAME) {
+      row += 1;
+      continue;
+    }
+    placements.set(segment, { order: ++order, row });
+  }
+  return placements;
 }
 
 function segmentControlHints(
-	width: number,
-	moveMode: boolean,
-	selected: SegmentName | undefined,
-	keybindings: Pick<KeybindingsManager, "getKeys">,
+  width: number,
+  moveMode: boolean,
+  selected: SegmentName | undefined,
+  keybindings: Pick<KeybindingsManager, "getKeys">,
 ): string[] {
-	const configuredCancel = [
-		...new Set(
-			keybindings
-				.getKeys("tui.select.cancel")
-				.filter((key) => key !== "ctrl+c")
-				.map(displayKey)
-				.filter(Boolean),
-		),
-	];
-	const closeKeys = [...new Set([...configuredCancel, "Ctrl+C"])].join("/");
-	if (moveMode) {
-		const cancellation = [
-			...(configuredCancel.length > 0 ? [`${configuredCancel.join("/")} leave move mode`] : []),
-			"Ctrl+C close",
-		].join(" · ");
-		return width < 30
-			? [
-					`Move mode: ${selected ?? "segment"}`,
-					"↑↓ move segment",
-					"Enter/Space finish",
-					...(configuredCancel.length > 0 ? [`${configuredCancel.join("/")} leave move mode`] : []),
-					"Ctrl+C close",
-				]
-			: [`Move mode — ${selected ?? "segment"}`, "↑↓ move · Enter/Space finish", cancellation];
-	}
-	return width < 30
-		? [
-				"↑↓ navigate",
-				"Enter/Space toggle",
-				"M move · B line break",
-				"Alt+↑/↓ quick move",
-				`${closeKeys} close`,
-			]
-		: [
-				"↑↓ navigate · Enter/Space show/hide · M move mode",
-				`B add/remove line break after · Alt+↑/↓ quick move · ${closeKeys} close`,
-			];
+  const configuredCancel = [
+    ...new Set(
+      keybindings
+        .getKeys("tui.select.cancel")
+        .filter((key) => key !== "ctrl+c")
+        .map(displayKey)
+        .filter(Boolean),
+    ),
+  ];
+  const closeKeys = [...new Set([...configuredCancel, "Ctrl+C"])].join("/");
+  if (moveMode) {
+    const cancellation = [
+      ...(configuredCancel.length > 0 ? [`${configuredCancel.join("/")} leave move mode`] : []),
+      "Ctrl+C close",
+    ].join(" · ");
+    return width < 30
+      ? [
+          `Move mode: ${selected ?? "segment"}`,
+          "↑↓ move segment",
+          "Enter/Space finish",
+          ...(configuredCancel.length > 0 ? [`${configuredCancel.join("/")} leave move mode`] : []),
+          "Ctrl+C close",
+        ]
+      : [`Move mode — ${selected ?? "segment"}`, "↑↓ move · Enter/Space finish", cancellation];
+  }
+  return width < 30
+    ? ["↑↓ navigate", "Enter/Space toggle", "M move · B line break", "Alt+↑/↓ quick move", `${closeKeys} close`]
+    : [
+        "↑↓ navigate · Enter/Space show/hide · M move mode",
+        `B add/remove line break after · Alt+↑/↓ quick move · ${closeKeys} close`,
+      ];
 }
 
 function displayKey(key: string): string {
-	return sanitizeTerminalText(key)
-		.split("+")
-		.map((part) => {
-			if (part === "escape") return "Esc";
-			if (part === "ctrl") return "Ctrl";
-			if (part === "alt") return process.platform === "darwin" ? "Option" : "Alt";
-			if (part === "shift") return "Shift";
-			return part;
-		})
-		.join("+");
+  return sanitizeTerminalText(key)
+    .split("+")
+    .map((part) => {
+      if (part === "escape") return "Esc";
+      if (part === "ctrl") return "Ctrl";
+      if (part === "alt") return process.platform === "darwin" ? "Option" : "Alt";
+      if (part === "shift") return "Shift";
+      return part;
+    })
+    .join("+");
 }
 
 function segmentsDocument(
-	current: LoadedStatuslineSettings,
-	name: SegmentName,
-	shouldShow: boolean,
+  current: LoadedStatuslineSettings,
+  name: SegmentName,
+  shouldShow: boolean,
 ): { nextDocument: string; previousDocument: string } {
-	const { parsed, rawDocument: previousDocument } = editableSettings(current, "changing segments");
-	const segments = shouldShow
-		? [...current.config.segments, ...(current.config.segments.includes(name) ? [] : [name])]
-		: current.config.segments.filter((segment) => segment !== name);
-	parsed.segments = normalizeLineBreaks(segments);
-	return {
-		nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
-		previousDocument,
-	};
+  const { parsed, rawDocument: previousDocument } = editableSettings(current, "changing segments");
+  const segments = shouldShow
+    ? [...current.config.segments, ...(current.config.segments.includes(name) ? [] : [name])]
+    : current.config.segments.filter((segment) => segment !== name);
+  parsed.segments = normalizeLineBreaks(segments);
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
+    previousDocument,
+  };
 }
 
 function lineBreakAfterDocument(
-	current: LoadedStatuslineSettings,
-	name: SegmentName,
+  current: LoadedStatuslineSettings,
+  name: SegmentName,
 ): { nextDocument: string; previousDocument: string } {
-	const { parsed, rawDocument: previousDocument } = editableSettings(
-		current,
-		"changing line breaks",
-	);
-	const segments = [...current.config.segments];
-	const segmentIndex = segments.indexOf(name);
-	if (segments[segmentIndex + 1] === LINE_BREAK_SEGMENT_NAME) {
-		segments.splice(segmentIndex + 1, 1);
-	} else {
-		segments.splice(segmentIndex + 1, 0, LINE_BREAK_SEGMENT_NAME);
-	}
-	parsed.segments = segments;
-	return {
-		nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
-		previousDocument,
-	};
+  const { parsed, rawDocument: previousDocument } = editableSettings(current, "changing line breaks");
+  const segments = [...current.config.segments];
+  const segmentIndex = segments.indexOf(name);
+  if (segments[segmentIndex + 1] === LINE_BREAK_SEGMENT_NAME) {
+    segments.splice(segmentIndex + 1, 1);
+  } else {
+    segments.splice(segmentIndex + 1, 0, LINE_BREAK_SEGMENT_NAME);
+  }
+  parsed.segments = segments;
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
+    previousDocument,
+  };
 }
 
 function reorderedSegmentsDocument(
-	current: LoadedStatuslineSettings,
-	name: SegmentName,
-	direction: -1 | 1,
+  current: LoadedStatuslineSettings,
+  name: SegmentName,
+  direction: -1 | 1,
 ): { nextDocument: string; previousDocument: string } | undefined {
-	const dataIndexes = current.config.segments.flatMap((segment, index) =>
-		segment === LINE_BREAK_SEGMENT_NAME ? [] : [index],
-	);
-	const currentDataIndex = dataIndexes.findIndex(
-		(index) => current.config.segments[index] === name,
-	);
-	const targetDataIndex = currentDataIndex + direction;
-	if (currentDataIndex < 0 || targetDataIndex < 0 || targetDataIndex >= dataIndexes.length) {
-		return undefined;
-	}
-	const { parsed, rawDocument: previousDocument } = editableSettings(
-		current,
-		"reordering segments",
-	);
-	const segments = [...current.config.segments];
-	const currentIndex = dataIndexes[currentDataIndex];
-	const targetIndex = dataIndexes[targetDataIndex];
-	if (currentIndex === undefined || targetIndex === undefined) return undefined;
-	[segments[currentIndex], segments[targetIndex]] = [segments[targetIndex], segments[currentIndex]];
-	parsed.segments = segments;
-	return {
-		nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
-		previousDocument,
-	};
+  const dataIndexes = current.config.segments.flatMap((segment, index) =>
+    segment === LINE_BREAK_SEGMENT_NAME ? [] : [index],
+  );
+  const currentDataIndex = dataIndexes.findIndex((index) => current.config.segments[index] === name);
+  const targetDataIndex = currentDataIndex + direction;
+  if (currentDataIndex < 0 || targetDataIndex < 0 || targetDataIndex >= dataIndexes.length) {
+    return undefined;
+  }
+  const { parsed, rawDocument: previousDocument } = editableSettings(current, "reordering segments");
+  const segments = [...current.config.segments];
+  const currentIndex = dataIndexes[currentDataIndex];
+  const targetIndex = dataIndexes[targetDataIndex];
+  if (currentIndex === undefined || targetIndex === undefined) return undefined;
+  [segments[currentIndex], segments[targetIndex]] = [segments[targetIndex], segments[currentIndex]];
+  parsed.segments = segments;
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "\t")}\n`,
+    previousDocument,
+  };
 }
 
 function applySegmentsDocumentChange(
-	change: { nextDocument: string; previousDocument: string },
-	ctx: ExtensionCommandContext,
-	options: StatuslineCommandOptions,
+  change: { nextDocument: string; previousDocument: string },
+  ctx: ExtensionCommandContext,
+  options: StatuslineCommandOptions,
 ): LoadedStatuslineSettings {
-	const previous = options.getLoaded();
-	const save = options.save ?? saveStatuslineSettingsDocument;
-	const next = save(options.settingsPath, change.nextDocument);
-	try {
-		options.apply(next, ctx);
-	} catch (applyError) {
-		const rollbackError = restoreStatuslineSettings(ctx, options, previous, next);
-		if (rollbackError) {
-			throw new Error(
-				`runtime update failed: ${formatError(applyError)}; rollback failed: ${formatError(rollbackError)}`,
-			);
-		}
-		throw applyError;
-	}
-	return next;
+  const previous = options.getLoaded();
+  const save = options.save ?? saveStatuslineSettingsDocument;
+  const next = save(options.settingsPath, change.nextDocument);
+  try {
+    options.apply(next, ctx);
+  } catch (applyError) {
+    const rollbackError = restoreStatuslineSettings(ctx, options, previous, next);
+    if (rollbackError) {
+      throw new Error(
+        `runtime update failed: ${formatError(applyError)}; rollback failed: ${formatError(rollbackError)}`,
+      );
+    }
+    throw applyError;
+  }
+  return next;
 }
 
 function restoreStatuslineSettings(
-	ctx: ExtensionCommandContext,
-	options: StatuslineCommandOptions,
-	previous: LoadedStatuslineSettings,
-	saved: LoadedStatuslineSettings,
+  ctx: ExtensionCommandContext,
+  options: StatuslineCommandOptions,
+  previous: LoadedStatuslineSettings,
+  saved: LoadedStatuslineSettings,
 ): unknown {
-	try {
-		if (saved.rawDocument === undefined || saved.fileIdentity === undefined) {
-			throw new Error("The saved settings document identity is unavailable");
-		}
-		removeStatuslineSettingsDocumentIfMatches(
-			options.settingsPath,
-			saved.rawDocument,
-			saved.fileIdentity,
-		);
-		if (previous.rawDocument === undefined || previous.settingsPath !== options.settingsPath) {
-			options.apply(previous, ctx);
-			return undefined;
-		}
-		const restored = (options.save ?? saveStatuslineSettingsDocument)(
-			options.settingsPath,
-			previous.rawDocument,
-		);
-		options.apply(restored, ctx);
-		return undefined;
-	} catch (error) {
-		return error;
-	}
+  try {
+    if (saved.rawDocument === undefined || saved.fileIdentity === undefined) {
+      throw new Error("The saved settings document identity is unavailable");
+    }
+    removeStatuslineSettingsDocumentIfMatches(options.settingsPath, saved.rawDocument, saved.fileIdentity);
+    if (previous.rawDocument === undefined || previous.settingsPath !== options.settingsPath) {
+      options.apply(previous, ctx);
+      return undefined;
+    }
+    const restored = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, previous.rawDocument);
+    options.apply(restored, ctx);
+    return undefined;
+  } catch (error) {
+    return error;
+  }
 }
 
 function normalizeLineBreaks(segments: readonly ConfigSegmentName[]): ConfigSegmentName[] {
-	const normalized: ConfigSegmentName[] = [];
-	for (const segment of segments) {
-		if (
-			segment === LINE_BREAK_SEGMENT_NAME &&
-			(normalized.length === 0 || normalized.at(-1) === LINE_BREAK_SEGMENT_NAME)
-		) {
-			continue;
-		}
-		normalized.push(segment);
-	}
-	if (normalized.at(-1) === LINE_BREAK_SEGMENT_NAME) normalized.pop();
-	return normalized;
+  const normalized: ConfigSegmentName[] = [];
+  for (const segment of segments) {
+    if (
+      segment === LINE_BREAK_SEGMENT_NAME &&
+      (normalized.length === 0 || normalized.at(-1) === LINE_BREAK_SEGMENT_NAME)
+    ) {
+      continue;
+    }
+    normalized.push(segment);
+  }
+  if (normalized.at(-1) === LINE_BREAK_SEGMENT_NAME) normalized.pop();
+  return normalized;
 }
 
 function editableSettings(
-	current: LoadedStatuslineSettings,
-	action: string,
+  current: LoadedStatuslineSettings,
+  action: string,
 ): { parsed: Record<string, unknown>; rawDocument: string } {
-	const rawDocument =
-		current.source === "user" && current.rawDocument !== undefined
-			? current.rawDocument
-			: current.source === "built-in" &&
-					current.rawDocument === undefined &&
-					current.diagnostics.length === 0
-				? DEFAULT_STATUSLINE_DOCUMENT
-				: undefined;
-	if (rawDocument === undefined || current.diagnostics.some((item) => item.code !== "unknown")) {
-		throw new Error(`Fix pi-statusline.json before ${action}`);
-	}
-	const parsed = JSON.parse(rawDocument) as unknown;
-	if (!isRecord(parsed)) throw new Error("Settings must contain a JSON object");
-	return { parsed, rawDocument };
+  const rawDocument =
+    current.source === "user" && current.rawDocument !== undefined
+      ? current.rawDocument
+      : current.source === "built-in" && current.rawDocument === undefined && current.diagnostics.length === 0
+        ? DEFAULT_STATUSLINE_DOCUMENT
+        : undefined;
+  if (rawDocument === undefined || current.diagnostics.some((item) => item.code !== "unknown")) {
+    throw new Error(`Fix pi-statusline.json before ${action}`);
+  }
+  const parsed = JSON.parse(rawDocument) as unknown;
+  if (!isRecord(parsed)) throw new Error("Settings must contain a JSON object");
+  return { parsed, rawDocument };
 }
 
 function showStatus(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
-	if (!canNotify(ctx)) return;
-	const loaded = options.getLoaded();
-	const diagnostics = loaded.diagnostics
-		.slice(0, 5)
-		.map((item) => `${item.path || "root"}: ${item.message}`)
-		.join("; ");
-	ctx.ui.notify(
-		[
-			`pi-statusline source: ${loaded.source}`,
-			`active path: ${loaded.settingsPath}`,
-			`save target: ${options.settingsPath}`,
-			`palette preset: ${loaded.config.palettePreset}`,
-			`density: ${loaded.config.density}`,
-			`separator: ${loaded.config.separator}`,
-			`information: ${inferInformationProfile(loaded.config.segments)}`,
-			`segments: ${loaded.config.segments.join(", ") || "none"}`,
-			diagnostics ? `warnings: ${diagnostics}` : "warnings: none",
-		].join("\n"),
-		loaded.diagnostics.length > 0 ? "warning" : "info",
-	);
+  if (!canNotify(ctx)) return;
+  const loaded = options.getLoaded();
+  const diagnostics = loaded.diagnostics
+    .slice(0, 5)
+    .map((item) => `${item.path || "root"}: ${item.message}`)
+    .join("; ");
+  ctx.ui.notify(
+    [
+      `pi-statusline source: ${loaded.source}`,
+      `active path: ${loaded.settingsPath}`,
+      `save target: ${options.settingsPath}`,
+      `palette preset: ${loaded.config.palettePreset}`,
+      `density: ${loaded.config.density}`,
+      `separator: ${loaded.config.separator}`,
+      `information: ${inferInformationProfile(loaded.config.segments)}`,
+      `segments: ${loaded.config.segments.join(", ") || "none"}`,
+      diagnostics ? `warnings: ${diagnostics}` : "warnings: none",
+    ].join("\n"),
+    loaded.diagnostics.length > 0 ? "warning" : "info",
+  );
 }
 
 function showHelp(ctx: ExtensionCommandContext, settingsPath: string) {
-	if (!canNotify(ctx)) return;
-	ctx.ui.notify(
-		[
-			"/statusline — open Appearance, Information, Advanced, Status, and Help",
-			"/statusline settings — edit and apply JSON",
-			"/statusline status — show source, path, information level, and warnings",
-			"/statusline help — show this help",
-			"Menu actions: Appearance, Information, Advanced, Status, Help.",
-			"Information levels: minimal, balanced, detailed; any other segment array is custom.",
-			"Advanced actions: Custom layout, Edit settings JSON, Back.",
-			`Settings: ${settingsPath}`,
-			"Fields: palettePreset, palette, density, separator, segments, segmentText, extensionStatusIcons",
-			"Named presets ignore but preserve palette; custom uses its per-segment fg/bg colors.",
-			"Responsive rows retain context, model, location, and active work before decorative data.",
-			"Custom layout can show, hide, reorder, or split data segments across rows.",
-			"Press M for move mode, Alt+Up/Alt+Down for quick move, and B for a line break.",
-			"Line breaks (line_break) may repeat when separated by data segments, but cannot be consecutive.",
-			"segmentText supports prefix and suffix strings around Pi-owned dynamic values.",
-			"segmentText.model also supports truncationLength, truncationSymbol, and truncationDirection (start, middle, end).",
-		].join("\n"),
-		"info",
-	);
+  if (!canNotify(ctx)) return;
+  ctx.ui.notify(
+    [
+      "/statusline — open Appearance, Information, Advanced, Status, and Help",
+      "/statusline settings — edit and apply JSON",
+      "/statusline status — show source, path, information level, and warnings",
+      "/statusline help — show this help",
+      "Menu actions: Appearance, Information, Advanced, Status, Help.",
+      "Information levels: minimal, balanced, detailed; any other segment array is custom.",
+      "Advanced actions: Custom layout, Edit settings JSON, Back.",
+      `Settings: ${settingsPath}`,
+      "Fields: palettePreset, palette, density, separator, segments, segmentText, extensionStatusIcons",
+      "Named presets ignore but preserve palette; custom uses its per-segment fg/bg colors.",
+      "Responsive rows retain context, model, location, and active work before decorative data.",
+      "Custom layout can show, hide, reorder, or split data segments across rows.",
+      "Press M for move mode, Alt+Up/Alt+Down for quick move, and B for a line break.",
+      "Line breaks (line_break) may repeat when separated by data segments, but cannot be consecutive.",
+      "segmentText supports prefix and suffix strings around Pi-owned dynamic values.",
+      "segmentText.model also supports truncationLength, truncationSymbol, and truncationDirection (start, middle, end).",
+    ].join("\n"),
+    "info",
+  );
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 function isPaletteName(value: PalettePreset): value is PaletteName {
-	return (PALETTE_NAMES as readonly PalettePreset[]).includes(value);
+  return (PALETTE_NAMES as readonly PalettePreset[]).includes(value);
 }
 
 function canNotify(ctx: ExtensionCommandContext): boolean {
-	return ctx.mode === "tui" || ctx.hasUI;
+  return ctx.mode === "tui" || ctx.hasUI;
 }
 
 function formatError(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
+  return error instanceof Error ? error.message : String(error);
 }