@narumitw/pi-statusline 0.50.0 → 0.50.1

package/src/settings.ts

@@ -5,698 +5,646 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { INFORMATION_PROFILES } from "./information-profiles.js";
 import { segmentPaletteForPreset } from "./presets/index.js";
 import {
-	type ConfigSegmentName,
-	DENSITIES,
-	LINE_BREAK_SEGMENT_NAME,
-	PALETTE_NAMES,
-	PALETTE_PRESET_NAMES,
-	type PaletteName,
-	SEGMENT_NAMES,
-	SEPARATOR_NAMES,
-	type SegmentName,
-	type SegmentPalette,
-	type StatuslineConfig,
-	TRUNCATION_DIRECTIONS,
+  type ConfigSegmentName,
+  DENSITIES,
+  LINE_BREAK_SEGMENT_NAME,
+  PALETTE_NAMES,
+  PALETTE_PRESET_NAMES,
+  type PaletteName,
+  SEGMENT_NAMES,
+  SEPARATOR_NAMES,
+  type SegmentName,
+  type SegmentPalette,
+  type StatuslineConfig,
+  TRUNCATION_DIRECTIONS,
 } from "./types.js";
 
 export const SETTINGS_FILE_NAME = "pi-statusline.json";
 const LEGACY_SETTINGS_FILE_NAME = "pi-statusline-settings.json";
 
 const DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS: Record<string, string> = {
-	accounts: "👤",
-	caffeinate: "💊",
-	"chrome-devtools": "🌐",
-	firecrawl: "🔥",
-	"github-pr": "🔎",
-	goal: "🎯",
-	"google-genai": "✨",
-	lsp: "🧰",
-	"plan-mode": "📝",
-	retry: "🔁",
-	subagents: "🧑‍🤝‍🧑",
-	sync: "🔄",
-	usage: "📊",
+  accounts: "👤",
+  caffeinate: "💊",
+  "chrome-devtools": "🌐",
+  firecrawl: "🔥",
+  "github-pr": "🔎",
+  goal: "🎯",
+  "google-genai": "✨",
+  lsp: "🧰",
+  "plan-mode": "📝",
+  retry: "🔁",
+  subagents: "🧑‍🤝‍🧑",
+  sync: "🔄",
+  usage: "📊",
 };
 
 export const DEFAULT_EXTENSION_STATUS_ICONS: Record<string, string> = {
-	...DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS,
-	"codex-usage": "📊",
-	pisync: "🔄",
-	"unknown-error-retry": "🔁",
+  ...DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS,
+  "codex-usage": "📊",
+  pisync: "🔄",
+  "unknown-error-retry": "🔁",
 };
 
 const LEGACY_STATUS_ICON_KEYS = {
-	pisync: "sync",
-	"unknown-error-retry": "retry",
+  pisync: "sync",
+  "unknown-error-retry": "retry",
 } as const;
 
 const DEFAULT_SEGMENTS: SegmentName[] = [...INFORMATION_PROFILES.balanced];
 
 export const DEFAULT_STATUSLINE_CONFIG: StatuslineConfig = {
-	palettePreset: "tokyo-night",
-	palette: segmentPaletteForPreset("tokyo-night"),
-	density: "compact",
-	separator: "none",
-	segments: DEFAULT_SEGMENTS,
-	segmentText: {
-		brand: { prefix: "", suffix: "" },
-		provider: { prefix: "🔌 ", suffix: "" },
-		model: {
-			prefix: "🤖 ",
-			suffix: "",
-			truncationLength: 36,
-			truncationSymbol: "…",
-			truncationDirection: "start",
-		},
-		thinking: { prefix: "🧠 ", suffix: "" },
-		cwd: { prefix: "📁 ", suffix: "" },
-		branch: { prefix: "🌿 ", suffix: "" },
-		tools: { prefix: "", suffix: "" },
-		context: { prefix: "🪟 ctx ", suffix: "" },
-		tokens: { prefix: "🔢 ", suffix: "" },
-		cache: { prefix: "📦 ", suffix: "" },
-		cost: { prefix: "💸 $", suffix: "" },
-		time: { prefix: "🕒 ", suffix: "" },
-		turn: { prefix: "🔁 #", suffix: "" },
-	},
-	extensionStatusIcons: DEFAULT_EXTENSION_STATUS_ICONS,
+  palettePreset: "tokyo-night",
+  palette: segmentPaletteForPreset("tokyo-night"),
+  density: "compact",
+  separator: "none",
+  segments: DEFAULT_SEGMENTS,
+  segmentText: {
+    brand: { prefix: "", suffix: "" },
+    provider: { prefix: "🔌 ", suffix: "" },
+    model: {
+      prefix: "🤖 ",
+      suffix: "",
+      truncationLength: 36,
+      truncationSymbol: "…",
+      truncationDirection: "start",
+    },
+    thinking: { prefix: "🧠 ", suffix: "" },
+    cwd: { prefix: "📁 ", suffix: "" },
+    branch: { prefix: "🌿 ", suffix: "" },
+    tools: { prefix: "", suffix: "" },
+    context: { prefix: "🪟 ctx ", suffix: "" },
+    tokens: { prefix: "🔢 ", suffix: "" },
+    cache: { prefix: "📦 ", suffix: "" },
+    cost: { prefix: "💸 $", suffix: "" },
+    time: { prefix: "🕒 ", suffix: "" },
+    turn: { prefix: "🔁 #", suffix: "" },
+  },
+  extensionStatusIcons: DEFAULT_EXTENSION_STATUS_ICONS,
 };
 
 const DEFAULT_STATUSLINE_DOCUMENT_CONFIG = {
-	palettePreset: DEFAULT_STATUSLINE_CONFIG.palettePreset,
-	density: DEFAULT_STATUSLINE_CONFIG.density,
-	separator: DEFAULT_STATUSLINE_CONFIG.separator,
-	segments: DEFAULT_SEGMENTS,
-	segmentText: DEFAULT_STATUSLINE_CONFIG.segmentText,
-	extensionStatusIcons: DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS,
+  palettePreset: DEFAULT_STATUSLINE_CONFIG.palettePreset,
+  density: DEFAULT_STATUSLINE_CONFIG.density,
+  separator: DEFAULT_STATUSLINE_CONFIG.separator,
+  segments: DEFAULT_SEGMENTS,
+  segmentText: DEFAULT_STATUSLINE_CONFIG.segmentText,
+  extensionStatusIcons: DEFAULT_DOCUMENT_EXTENSION_STATUS_ICONS,
 } satisfies Omit<StatuslineConfig, "palette">;
 
-export const DEFAULT_STATUSLINE_DOCUMENT = `${JSON.stringify(
-	DEFAULT_STATUSLINE_DOCUMENT_CONFIG,
-	null,
-	"\t",
-)}\n`;
+export const DEFAULT_STATUSLINE_DOCUMENT = `${JSON.stringify(DEFAULT_STATUSLINE_DOCUMENT_CONFIG, null, "\t")}\n`;
 
 export interface StatuslineConfigDiagnostic {
-	severity: "warning" | "error";
-	code: "unknown" | "invalid" | "parse" | "io";
-	path: string;
-	message: string;
+  severity: "warning" | "error";
+  code: "unknown" | "invalid" | "parse" | "io";
+  path: string;
+  message: string;
 }
 
 export interface LoadedStatuslineSettings {
-	config: StatuslineConfig;
-	source: "built-in" | "user";
-	settingsPath: string;
-	rawDocument?: string;
-	fileIdentity?: { dev: number; ino: number };
-	diagnostics: StatuslineConfigDiagnostic[];
+  config: StatuslineConfig;
+  source: "built-in" | "user";
+  settingsPath: string;
+  rawDocument?: string;
+  fileIdentity?: { dev: number; ino: number };
+  diagnostics: StatuslineConfigDiagnostic[];
 }
 
 interface AtomicFileSystem {
-	mkdirSync: typeof mkdirSync;
-	writeFileSync: typeof writeFileSync;
-	renameSync: typeof renameSync;
-	rmSync: typeof rmSync;
+  mkdirSync: typeof mkdirSync;
+  writeFileSync: typeof writeFileSync;
+  renameSync: typeof renameSync;
+  rmSync: typeof rmSync;
 }
 
 let pendingSettingsNotice: string | undefined;
 
 export function settingsFilePath(agentDir = getAgentDir()): string {
-	return join(agentDir, SETTINGS_FILE_NAME);
+  return join(agentDir, SETTINGS_FILE_NAME);
 }
 
 export function createDefaultConfig(): StatuslineConfig {
-	return cloneConfig(DEFAULT_STATUSLINE_CONFIG);
+  return cloneConfig(DEFAULT_STATUSLINE_CONFIG);
 }
 
 export function normalizeStatuslineConfig(value: unknown): {
-	config: StatuslineConfig;
-	diagnostics: StatuslineConfigDiagnostic[];
+  config: StatuslineConfig;
+  diagnostics: StatuslineConfigDiagnostic[];
 } {
-	const config = createDefaultConfig();
-	const diagnostics: StatuslineConfigDiagnostic[] = [];
-	if (!isRecord(value)) {
-		return {
-			config,
-			diagnostics: [invalidDiagnostic("", "Settings must contain a JSON object", "error")],
-		};
-	}
-	const knownRoot = new Set([
-		"palettePreset",
-		"palette",
-		"density",
-		"separator",
-		"segments",
-		"segmentText",
-		"extensionStatusIcons",
-	]);
-	for (const key of Object.keys(value)) {
-		if (!knownRoot.has(key)) diagnostics.push(unknownDiagnostic(key));
-	}
-
-	normalizePalette(value.palette, config, diagnostics);
-	normalizeEnum(value, "palettePreset", PALETTE_PRESET_NAMES, config, diagnostics);
-	if (!isRecord(value.palette) && isPaletteName(config.palettePreset)) {
-		config.palette = segmentPaletteForPreset(config.palettePreset);
-	}
-	normalizeEnum(value, "density", DENSITIES, config, diagnostics);
-	normalizeEnum(value, "separator", SEPARATOR_NAMES, config, diagnostics);
-
-	if (value.segments !== undefined) {
-		if (!Array.isArray(value.segments)) {
-			diagnostics.push(invalidDiagnostic("segments", "Expected an array of segment names"));
-		} else {
-			const segments: ConfigSegmentName[] = [];
-			const seen = new Set<SegmentName>();
-			for (const [index, item] of value.segments.entries()) {
-				const path = `segments[${index}]`;
-				if (typeof item !== "string" || !isConfigSegmentName(item)) {
-					diagnostics.push(invalidDiagnostic(path, "Unknown or non-string segment name"));
-					continue;
-				}
-				if (item === LINE_BREAK_SEGMENT_NAME) {
-					if (segments.at(-1) === LINE_BREAK_SEGMENT_NAME) {
-						diagnostics.push(
-							invalidDiagnostic(path, "Consecutive line_break segments are not allowed"),
-						);
-						continue;
-					}
-					segments.push(item);
-					continue;
-				}
-				if (seen.has(item)) {
-					diagnostics.push(invalidDiagnostic(path, `Duplicate segment ${JSON.stringify(item)}`));
-					continue;
-				}
-				seen.add(item);
-				segments.push(item);
-			}
-			config.segments = segments;
-		}
-	}
-
-	if (value.segmentText !== undefined) {
-		if (!isRecord(value.segmentText)) {
-			diagnostics.push(invalidDiagnostic("segmentText", "Expected an object"));
-		} else {
-			for (const [name, presentation] of Object.entries(value.segmentText)) {
-				const path = `segmentText.${name}`;
-				if (!isSegmentName(name)) {
-					diagnostics.push(unknownDiagnostic(path));
-					continue;
-				}
-				if (!isRecord(presentation)) {
-					diagnostics.push(invalidDiagnostic(path, "Expected an object"));
-					continue;
-				}
-				const knownFields = new Set([
-					"prefix",
-					"suffix",
-					...(name === "model"
-						? ["truncationLength", "truncationSymbol", "truncationDirection"]
-						: []),
-				]);
-				for (const key of Object.keys(presentation)) {
-					if (!knownFields.has(key)) diagnostics.push(unknownDiagnostic(`${path}.${key}`));
-				}
-				for (const field of ["prefix", "suffix"] as const) {
-					const fieldValue = presentation[field];
-					if (fieldValue === undefined) continue;
-					if (!isSafeSegmentText(fieldValue, `${path}.${field}`, diagnostics)) continue;
-					config.segmentText[name][field] = fieldValue;
-				}
-				if (name === "model") {
-					normalizeModelTruncation(presentation, config, diagnostics);
-				}
-			}
-		}
-	}
-
-	if (value.extensionStatusIcons !== undefined) {
-		if (!isRecord(value.extensionStatusIcons)) {
-			diagnostics.push(invalidDiagnostic("extensionStatusIcons", "Expected an object"));
-		} else {
-			for (const [key, icon] of Object.entries(value.extensionStatusIcons)) {
-				if (typeof icon !== "string") {
-					diagnostics.push(invalidDiagnostic(`extensionStatusIcons.${key}`, "Expected a string"));
-					continue;
-				}
-				Object.defineProperty(config.extensionStatusIcons, key, {
-					value: icon,
-					enumerable: true,
-					configurable: true,
-					writable: true,
-				});
-			}
-			for (const [legacyKey, canonicalKey] of Object.entries(LEGACY_STATUS_ICON_KEYS)) {
-				const legacyIcon = Object.hasOwn(value.extensionStatusIcons, legacyKey)
-					? value.extensionStatusIcons[legacyKey]
-					: undefined;
-				const canonicalIcon = Object.hasOwn(value.extensionStatusIcons, canonicalKey)
-					? value.extensionStatusIcons[canonicalKey]
-					: undefined;
-				const targetKey = typeof canonicalIcon === "string" ? legacyKey : canonicalKey;
-				const inheritedIcon =
-					typeof canonicalIcon === "string"
-						? canonicalIcon
-						: typeof legacyIcon === "string"
-							? legacyIcon
-							: undefined;
-				if (inheritedIcon === undefined) continue;
-				Object.defineProperty(config.extensionStatusIcons, targetKey, {
-					value: inheritedIcon,
-					enumerable: true,
-					configurable: true,
-					writable: true,
-				});
-			}
-		}
-	}
-
-	return { config, diagnostics };
+  const config = createDefaultConfig();
+  const diagnostics: StatuslineConfigDiagnostic[] = [];
+  if (!isRecord(value)) {
+    return {
+      config,
+      diagnostics: [invalidDiagnostic("", "Settings must contain a JSON object", "error")],
+    };
+  }
+  const knownRoot = new Set([
+    "palettePreset",
+    "palette",
+    "density",
+    "separator",
+    "segments",
+    "segmentText",
+    "extensionStatusIcons",
+  ]);
+  for (const key of Object.keys(value)) {
+    if (!knownRoot.has(key)) diagnostics.push(unknownDiagnostic(key));
+  }
+
+  normalizePalette(value.palette, config, diagnostics);
+  normalizeEnum(value, "palettePreset", PALETTE_PRESET_NAMES, config, diagnostics);
+  if (!isRecord(value.palette) && isPaletteName(config.palettePreset)) {
+    config.palette = segmentPaletteForPreset(config.palettePreset);
+  }
+  normalizeEnum(value, "density", DENSITIES, config, diagnostics);
+  normalizeEnum(value, "separator", SEPARATOR_NAMES, config, diagnostics);
+
+  if (value.segments !== undefined) {
+    if (!Array.isArray(value.segments)) {
+      diagnostics.push(invalidDiagnostic("segments", "Expected an array of segment names"));
+    } else {
+      const segments: ConfigSegmentName[] = [];
+      const seen = new Set<SegmentName>();
+      for (const [index, item] of value.segments.entries()) {
+        const path = `segments[${index}]`;
+        if (typeof item !== "string" || !isConfigSegmentName(item)) {
+          diagnostics.push(invalidDiagnostic(path, "Unknown or non-string segment name"));
+          continue;
+        }
+        if (item === LINE_BREAK_SEGMENT_NAME) {
+          if (segments.at(-1) === LINE_BREAK_SEGMENT_NAME) {
+            diagnostics.push(invalidDiagnostic(path, "Consecutive line_break segments are not allowed"));
+            continue;
+          }
+          segments.push(item);
+          continue;
+        }
+        if (seen.has(item)) {
+          diagnostics.push(invalidDiagnostic(path, `Duplicate segment ${JSON.stringify(item)}`));
+          continue;
+        }
+        seen.add(item);
+        segments.push(item);
+      }
+      config.segments = segments;
+    }
+  }
+
+  if (value.segmentText !== undefined) {
+    if (!isRecord(value.segmentText)) {
+      diagnostics.push(invalidDiagnostic("segmentText", "Expected an object"));
+    } else {
+      for (const [name, presentation] of Object.entries(value.segmentText)) {
+        const path = `segmentText.${name}`;
+        if (!isSegmentName(name)) {
+          diagnostics.push(unknownDiagnostic(path));
+          continue;
+        }
+        if (!isRecord(presentation)) {
+          diagnostics.push(invalidDiagnostic(path, "Expected an object"));
+          continue;
+        }
+        const knownFields = new Set([
+          "prefix",
+          "suffix",
+          ...(name === "model" ? ["truncationLength", "truncationSymbol", "truncationDirection"] : []),
+        ]);
+        for (const key of Object.keys(presentation)) {
+          if (!knownFields.has(key)) diagnostics.push(unknownDiagnostic(`${path}.${key}`));
+        }
+        for (const field of ["prefix", "suffix"] as const) {
+          const fieldValue = presentation[field];
+          if (fieldValue === undefined) continue;
+          if (!isSafeSegmentText(fieldValue, `${path}.${field}`, diagnostics)) continue;
+          config.segmentText[name][field] = fieldValue;
+        }
+        if (name === "model") {
+          normalizeModelTruncation(presentation, config, diagnostics);
+        }
+      }
+    }
+  }
+
+  if (value.extensionStatusIcons !== undefined) {
+    if (!isRecord(value.extensionStatusIcons)) {
+      diagnostics.push(invalidDiagnostic("extensionStatusIcons", "Expected an object"));
+    } else {
+      for (const [key, icon] of Object.entries(value.extensionStatusIcons)) {
+        if (typeof icon !== "string") {
+          diagnostics.push(invalidDiagnostic(`extensionStatusIcons.${key}`, "Expected a string"));
+          continue;
+        }
+        Object.defineProperty(config.extensionStatusIcons, key, {
+          value: icon,
+          enumerable: true,
+          configurable: true,
+          writable: true,
+        });
+      }
+      for (const [legacyKey, canonicalKey] of Object.entries(LEGACY_STATUS_ICON_KEYS)) {
+        const legacyIcon = Object.hasOwn(value.extensionStatusIcons, legacyKey)
+          ? value.extensionStatusIcons[legacyKey]
+          : undefined;
+        const canonicalIcon = Object.hasOwn(value.extensionStatusIcons, canonicalKey)
+          ? value.extensionStatusIcons[canonicalKey]
+          : undefined;
+        const targetKey = typeof canonicalIcon === "string" ? legacyKey : canonicalKey;
+        const inheritedIcon =
+          typeof canonicalIcon === "string" ? canonicalIcon : typeof legacyIcon === "string" ? legacyIcon : undefined;
+        if (inheritedIcon === undefined) continue;
+        Object.defineProperty(config.extensionStatusIcons, targetKey, {
+          value: inheritedIcon,
+          enumerable: true,
+          configurable: true,
+          writable: true,
+        });
+      }
+    }
+  }
+
+  return { config, diagnostics };
 }
 
 export function loadStatuslineSettings(settingsPath: string): LoadedStatuslineSettings {
-	let rawDocument: string;
-	try {
-		rawDocument = readFileSync(settingsPath, "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT" && !pathExists(settingsPath)) {
-			return builtInSettings(settingsPath);
-		}
-		return builtInSettings(settingsPath, [
-			diagnostic("error", "io", "", `Unable to read settings: ${formatError(error)}`),
-		]);
-	}
-
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(rawDocument);
-	} catch (error) {
-		return {
-			...builtInSettings(settingsPath, [
-				diagnostic("error", "parse", "", `Unable to parse JSON: ${formatError(error)}`),
-			]),
-			rawDocument,
-		};
-	}
-	const normalized = normalizeStatuslineConfig(parsed);
-	return {
-		config: normalized.config,
-		source: normalized.diagnostics.some((item) => item.severity === "error") ? "built-in" : "user",
-		settingsPath,
-		rawDocument,
-		diagnostics: normalized.diagnostics,
-	};
+  let rawDocument: string;
+  try {
+    rawDocument = readFileSync(settingsPath, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT" && !pathExists(settingsPath)) {
+      return builtInSettings(settingsPath);
+    }
+    return builtInSettings(settingsPath, [
+      diagnostic("error", "io", "", `Unable to read settings: ${formatError(error)}`),
+    ]);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(rawDocument);
+  } catch (error) {
+    return {
+      ...builtInSettings(settingsPath, [
+        diagnostic("error", "parse", "", `Unable to parse JSON: ${formatError(error)}`),
+      ]),
+      rawDocument,
+    };
+  }
+  const normalized = normalizeStatuslineConfig(parsed);
+  return {
+    config: normalized.config,
+    source: normalized.diagnostics.some((item) => item.severity === "error") ? "built-in" : "user",
+    settingsPath,
+    rawDocument,
+    diagnostics: normalized.diagnostics,
+  };
 }
 
 export function loadStatuslineSettingsForAgent(agentDir = getAgentDir()): LoadedStatuslineSettings {
-	pendingSettingsNotice = undefined;
-	const canonicalPath = settingsFilePath(agentDir);
-	const legacyPath = join(agentDir, LEGACY_SETTINGS_FILE_NAME);
-	const canonical = loadStatuslineSettings(canonicalPath);
-	if (!isMissingStatuslineSettings(canonical)) {
-		if (!isMissingStatuslineSettings(loadStatuslineSettings(legacyPath))) {
-			pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} takes precedence.`;
-		}
-		return canonical;
-	}
-	const legacy = loadStatuslineSettings(legacyPath);
-	return isMissingStatuslineSettings(legacy)
-		? canonical
-		: migrateLegacySettings(canonicalPath, legacy);
-}
-
-function migrateLegacySettings(
-	canonicalPath: string,
-	legacy: LoadedStatuslineSettings,
-): LoadedStatuslineSettings {
-	const racedCanonical = loadStatuslineSettings(canonicalPath);
-	if (!isMissingStatuslineSettings(racedCanonical)) {
-		pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} was created concurrently.`;
-		return racedCanonical;
-	}
-	if (
-		legacy.source !== "user" ||
-		legacy.rawDocument === undefined ||
-		blockingDiagnostics(legacy.diagnostics).length > 0
-	) {
-		pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} is invalid and was ignored.`;
-		return legacy;
-	}
-	pendingSettingsNotice = `Using legacy ${LEGACY_SETTINGS_FILE_NAME}; rename it to ${SETTINGS_FILE_NAME}. Future saves write ${SETTINGS_FILE_NAME} without modifying the legacy file.`;
-	return legacy;
+  pendingSettingsNotice = undefined;
+  const canonicalPath = settingsFilePath(agentDir);
+  const legacyPath = join(agentDir, LEGACY_SETTINGS_FILE_NAME);
+  const canonical = loadStatuslineSettings(canonicalPath);
+  if (!isMissingStatuslineSettings(canonical)) {
+    if (!isMissingStatuslineSettings(loadStatuslineSettings(legacyPath))) {
+      pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} takes precedence.`;
+    }
+    return canonical;
+  }
+  const legacy = loadStatuslineSettings(legacyPath);
+  return isMissingStatuslineSettings(legacy) ? canonical : migrateLegacySettings(canonicalPath, legacy);
+}
+
+function migrateLegacySettings(canonicalPath: string, legacy: LoadedStatuslineSettings): LoadedStatuslineSettings {
+  const racedCanonical = loadStatuslineSettings(canonicalPath);
+  if (!isMissingStatuslineSettings(racedCanonical)) {
+    pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} ignored because ${SETTINGS_FILE_NAME} was created concurrently.`;
+    return racedCanonical;
+  }
+  if (
+    legacy.source !== "user" ||
+    legacy.rawDocument === undefined ||
+    blockingDiagnostics(legacy.diagnostics).length > 0
+  ) {
+    pendingSettingsNotice = `${LEGACY_SETTINGS_FILE_NAME} is invalid and was ignored.`;
+    return legacy;
+  }
+  pendingSettingsNotice = `Using legacy ${LEGACY_SETTINGS_FILE_NAME}; rename it to ${SETTINGS_FILE_NAME}. Future saves write ${SETTINGS_FILE_NAME} without modifying the legacy file.`;
+  return legacy;
 }
 
 function isMissingStatuslineSettings(settings: LoadedStatuslineSettings): boolean {
-	return (
-		settings.source === "built-in" &&
-		settings.rawDocument === undefined &&
-		settings.diagnostics.length === 0
-	);
+  return settings.source === "built-in" && settings.rawDocument === undefined && settings.diagnostics.length === 0;
 }
 
 export function saveStatuslineSettingsDocument(
-	settingsPath: string,
-	rawDocument: string,
-	overrides: Partial<AtomicFileSystem> = {},
+  settingsPath: string,
+  rawDocument: string,
+  overrides: Partial<AtomicFileSystem> = {},
 ): LoadedStatuslineSettings {
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(rawDocument);
-	} catch (error) {
-		throw new Error(`Unable to parse JSON: ${formatError(error)}`);
-	}
-	const normalized = normalizeStatuslineConfig(parsed);
-	const blocking = blockingDiagnostics(normalized.diagnostics);
-	if (blocking.length > 0) {
-		throw new Error(blocking.map((item) => `${item.path || "root"}: ${item.message}`).join("\n"));
-	}
-
-	const fs = { mkdirSync, writeFileSync, renameSync, rmSync, ...overrides };
-	const replaceExisting = pathEntryExists(settingsPath);
-	const temporaryPath = temporarySettingsPath(settingsPath);
-	let fileIdentity: { dev: number; ino: number } | undefined;
-	try {
-		fs.mkdirSync(dirname(settingsPath), { recursive: true });
-		fs.writeFileSync(temporaryPath, rawDocument, { encoding: "utf8", flag: "wx" });
-		const info = lstatSync(temporaryPath);
-		fileIdentity = { dev: info.dev, ino: info.ino };
-		if (!replaceExisting && pathEntryExists(settingsPath)) {
-			throw new Error(`${SETTINGS_FILE_NAME} was created concurrently; reopen settings and retry.`);
-		}
-		fs.renameSync(temporaryPath, settingsPath);
-	} finally {
-		removeTemporaryFile(fs.rmSync, temporaryPath);
-	}
-	return {
-		config: normalized.config,
-		source: "user",
-		settingsPath,
-		rawDocument,
-		...(fileIdentity ? { fileIdentity } : {}),
-		diagnostics: normalized.diagnostics,
-	};
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(rawDocument);
+  } catch (error) {
+    throw new Error(`Unable to parse JSON: ${formatError(error)}`);
+  }
+  const normalized = normalizeStatuslineConfig(parsed);
+  const blocking = blockingDiagnostics(normalized.diagnostics);
+  if (blocking.length > 0) {
+    throw new Error(blocking.map((item) => `${item.path || "root"}: ${item.message}`).join("\n"));
+  }
+
+  const fs = { mkdirSync, writeFileSync, renameSync, rmSync, ...overrides };
+  const replaceExisting = pathEntryExists(settingsPath);
+  const temporaryPath = temporarySettingsPath(settingsPath);
+  let fileIdentity: { dev: number; ino: number } | undefined;
+  try {
+    fs.mkdirSync(dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(temporaryPath, rawDocument, { encoding: "utf8", flag: "wx" });
+    const info = lstatSync(temporaryPath);
+    fileIdentity = { dev: info.dev, ino: info.ino };
+    if (!replaceExisting && pathEntryExists(settingsPath)) {
+      throw new Error(`${SETTINGS_FILE_NAME} was created concurrently; reopen settings and retry.`);
+    }
+    fs.renameSync(temporaryPath, settingsPath);
+  } finally {
+    removeTemporaryFile(fs.rmSync, temporaryPath);
+  }
+  return {
+    config: normalized.config,
+    source: "user",
+    settingsPath,
+    rawDocument,
+    ...(fileIdentity ? { fileIdentity } : {}),
+    diagnostics: normalized.diagnostics,
+  };
 }
 
 export function removeStatuslineSettingsDocumentIfMatches(
-	settingsPath: string,
-	expectedRawDocument: string,
-	expectedIdentity: { dev: number; ino: number },
+  settingsPath: string,
+  expectedRawDocument: string,
+  expectedIdentity: { dev: number; ino: number },
 ): void {
-	const quarantinePath = join(
-		dirname(settingsPath),
-		`.${SETTINGS_FILE_NAME}.${randomUUID()}.rollback`,
-	);
-	const before = lstatSync(settingsPath);
-	if (before.dev !== expectedIdentity.dev || before.ino !== expectedIdentity.ino) {
-		throw new Error("Statusline settings changed concurrently; the newer file was preserved");
-	}
-	renameSync(settingsPath, quarantinePath);
-	const quarantined = lstatSync(quarantinePath);
-	const quarantinedSavedFile =
-		quarantined.isFile() &&
-		!quarantined.isSymbolicLink() &&
-		quarantined.dev === expectedIdentity.dev &&
-		quarantined.ino === expectedIdentity.ino;
-	if (quarantinedSavedFile && readFileSync(quarantinePath, "utf8") === expectedRawDocument) {
-		rmSync(quarantinePath);
-		return;
-	}
-	if (quarantinedSavedFile && !pathEntryExists(settingsPath)) {
-		try {
-			renameSync(quarantinePath, settingsPath);
-		} catch {
-			// Keep the quarantine for recovery when its atomic restoration fails.
-		}
-	}
-	throw new Error("Statusline settings changed concurrently; the newer file was preserved");
+  const quarantinePath = join(dirname(settingsPath), `.${SETTINGS_FILE_NAME}.${randomUUID()}.rollback`);
+  const before = lstatSync(settingsPath);
+  if (before.dev !== expectedIdentity.dev || before.ino !== expectedIdentity.ino) {
+    throw new Error("Statusline settings changed concurrently; the newer file was preserved");
+  }
+  renameSync(settingsPath, quarantinePath);
+  const quarantined = lstatSync(quarantinePath);
+  const quarantinedSavedFile =
+    quarantined.isFile() &&
+    !quarantined.isSymbolicLink() &&
+    quarantined.dev === expectedIdentity.dev &&
+    quarantined.ino === expectedIdentity.ino;
+  if (quarantinedSavedFile && readFileSync(quarantinePath, "utf8") === expectedRawDocument) {
+    rmSync(quarantinePath);
+    return;
+  }
+  if (quarantinedSavedFile && !pathEntryExists(settingsPath)) {
+    try {
+      renameSync(quarantinePath, settingsPath);
+    } catch {
+      // Keep the quarantine for recovery when its atomic restoration fails.
+    }
+  }
+  throw new Error("Statusline settings changed concurrently; the newer file was preserved");
 }
 
 export function consumeStatuslineSettingsNotice(): string | undefined {
-	const notice = pendingSettingsNotice;
-	pendingSettingsNotice = undefined;
-	return notice;
+  const notice = pendingSettingsNotice;
+  pendingSettingsNotice = undefined;
+  return notice;
 }
 
 export function readStatuslineSettings(settingsPath?: string): StatuslineConfig {
-	return settingsPath
-		? loadStatuslineSettings(settingsPath).config
-		: loadStatuslineSettingsForAgent().config;
+  return settingsPath ? loadStatuslineSettings(settingsPath).config : loadStatuslineSettingsForAgent().config;
 }
 
 export function normalizeStatuslineSettings(value: unknown): StatuslineConfig {
-	return normalizeStatuslineConfig(value).config;
-}
-
-function normalizePalette(
-	value: unknown,
-	config: StatuslineConfig,
-	diagnostics: StatuslineConfigDiagnostic[],
-) {
-	if (value === undefined) return;
-	if (typeof value === "string") {
-		if (!(PALETTE_NAMES as readonly string[]).includes(value)) {
-			diagnostics.push(
-				invalidDiagnostic(
-					"palette",
-					`Expected a palette object or one of: ${PALETTE_NAMES.join(", ")}`,
-				),
-			);
-			return;
-		}
-		config.palettePreset = value as (typeof PALETTE_NAMES)[number];
-		return;
-	}
-	if (!isRecord(value)) {
-		diagnostics.push(invalidDiagnostic("palette", "Expected a palette object"));
-		return;
-	}
-
-	const palette: SegmentPalette = {};
-	config.palette = palette;
-	for (const [name, colors] of Object.entries(value)) {
-		const path = `palette.${name}`;
-		if (!isSegmentName(name)) {
-			diagnostics.push(unknownDiagnostic(path));
-			continue;
-		}
-		if (!isRecord(colors)) {
-			diagnostics.push(invalidDiagnostic(path, "Expected an object"));
-			continue;
-		}
-		const normalizedColors: NonNullable<SegmentPalette[SegmentName]> = {};
-		palette[name] = normalizedColors;
-		for (const [field, color] of Object.entries(colors)) {
-			const colorPath = `${path}.${field}`;
-			if (field !== "fg" && field !== "bg") {
-				diagnostics.push(unknownDiagnostic(colorPath));
-				continue;
-			}
-			if (typeof color !== "string" || !/^#[0-9a-f]{6}$/iu.test(color)) {
-				diagnostics.push(invalidDiagnostic(colorPath, "Expected a full #RRGGBB hexadecimal color"));
-				continue;
-			}
-			normalizedColors[field] = color.toLowerCase();
-		}
-	}
-	config.palette = palette;
-	config.palettePreset = "custom";
+  return normalizeStatuslineConfig(value).config;
+}
+
+function normalizePalette(value: unknown, config: StatuslineConfig, diagnostics: StatuslineConfigDiagnostic[]) {
+  if (value === undefined) return;
+  if (typeof value === "string") {
+    if (!(PALETTE_NAMES as readonly string[]).includes(value)) {
+      diagnostics.push(
+        invalidDiagnostic("palette", `Expected a palette object or one of: ${PALETTE_NAMES.join(", ")}`),
+      );
+      return;
+    }
+    config.palettePreset = value as (typeof PALETTE_NAMES)[number];
+    return;
+  }
+  if (!isRecord(value)) {
+    diagnostics.push(invalidDiagnostic("palette", "Expected a palette object"));
+    return;
+  }
+
+  const palette: SegmentPalette = {};
+  config.palette = palette;
+  for (const [name, colors] of Object.entries(value)) {
+    const path = `palette.${name}`;
+    if (!isSegmentName(name)) {
+      diagnostics.push(unknownDiagnostic(path));
+      continue;
+    }
+    if (!isRecord(colors)) {
+      diagnostics.push(invalidDiagnostic(path, "Expected an object"));
+      continue;
+    }
+    const normalizedColors: NonNullable<SegmentPalette[SegmentName]> = {};
+    palette[name] = normalizedColors;
+    for (const [field, color] of Object.entries(colors)) {
+      const colorPath = `${path}.${field}`;
+      if (field !== "fg" && field !== "bg") {
+        diagnostics.push(unknownDiagnostic(colorPath));
+        continue;
+      }
+      if (typeof color !== "string" || !/^#[0-9a-f]{6}$/iu.test(color)) {
+        diagnostics.push(invalidDiagnostic(colorPath, "Expected a full #RRGGBB hexadecimal color"));
+        continue;
+      }
+      normalizedColors[field] = color.toLowerCase();
+    }
+  }
+  config.palette = palette;
+  config.palettePreset = "custom";
 }
 
 function normalizeModelTruncation(
-	presentation: Record<string, unknown>,
-	config: StatuslineConfig,
-	diagnostics: StatuslineConfigDiagnostic[],
+  presentation: Record<string, unknown>,
+  config: StatuslineConfig,
+  diagnostics: StatuslineConfigDiagnostic[],
 ) {
-	const path = "segmentText.model";
-	const length = presentation.truncationLength;
-	if (length !== undefined) {
-		if (typeof length !== "number" || !Number.isInteger(length) || length < 0 || length > 1000) {
-			diagnostics.push(
-				invalidDiagnostic(`${path}.truncationLength`, "Expected an integer from 0 through 1000"),
-			);
-		} else config.segmentText.model.truncationLength = length;
-	}
-
-	const symbol = presentation.truncationSymbol;
-	if (symbol !== undefined && isSafeSegmentText(symbol, `${path}.truncationSymbol`, diagnostics)) {
-		config.segmentText.model.truncationSymbol = symbol;
-	}
-
-	const direction = presentation.truncationDirection;
-	if (direction !== undefined) {
-		if (
-			typeof direction !== "string" ||
-			!TRUNCATION_DIRECTIONS.includes(direction as (typeof TRUNCATION_DIRECTIONS)[number])
-		) {
-			diagnostics.push(
-				invalidDiagnostic(
-					`${path}.truncationDirection`,
-					`Expected one of: ${TRUNCATION_DIRECTIONS.join(", ")}`,
-				),
-			);
-		} else {
-			config.segmentText.model.truncationDirection =
-				direction as (typeof TRUNCATION_DIRECTIONS)[number];
-		}
-	}
-}
-
-function isSafeSegmentText(
-	value: unknown,
-	path: string,
-	diagnostics: StatuslineConfigDiagnostic[],
-): value is string {
-	if (typeof value !== "string") {
-		diagnostics.push(invalidDiagnostic(path, "Expected a string"));
-		return false;
-	}
-	if (/[\r\n\u2028\u2029]/u.test(value)) {
-		diagnostics.push(invalidDiagnostic(path, "Line breaks are not allowed; use line_break"));
-		return false;
-	}
-	if (hasControlCharacter(value)) {
-		diagnostics.push(invalidDiagnostic(path, "Control characters are not allowed"));
-		return false;
-	}
-	return true;
-}
-
-function normalizeEnum<
-	K extends "palettePreset" | "density" | "separator",
-	T extends StatuslineConfig[K],
->(
-	value: Record<string, unknown>,
-	field: K,
-	accepted: readonly T[],
-	config: StatuslineConfig,
-	diagnostics: StatuslineConfigDiagnostic[],
+  const path = "segmentText.model";
+  const length = presentation.truncationLength;
+  if (length !== undefined) {
+    if (typeof length !== "number" || !Number.isInteger(length) || length < 0 || length > 1000) {
+      diagnostics.push(invalidDiagnostic(`${path}.truncationLength`, "Expected an integer from 0 through 1000"));
+    } else config.segmentText.model.truncationLength = length;
+  }
+
+  const symbol = presentation.truncationSymbol;
+  if (symbol !== undefined && isSafeSegmentText(symbol, `${path}.truncationSymbol`, diagnostics)) {
+    config.segmentText.model.truncationSymbol = symbol;
+  }
+
+  const direction = presentation.truncationDirection;
+  if (direction !== undefined) {
+    if (
+      typeof direction !== "string" ||
+      !TRUNCATION_DIRECTIONS.includes(direction as (typeof TRUNCATION_DIRECTIONS)[number])
+    ) {
+      diagnostics.push(
+        invalidDiagnostic(`${path}.truncationDirection`, `Expected one of: ${TRUNCATION_DIRECTIONS.join(", ")}`),
+      );
+    } else {
+      config.segmentText.model.truncationDirection = direction as (typeof TRUNCATION_DIRECTIONS)[number];
+    }
+  }
+}
+
+function isSafeSegmentText(value: unknown, path: string, diagnostics: StatuslineConfigDiagnostic[]): value is string {
+  if (typeof value !== "string") {
+    diagnostics.push(invalidDiagnostic(path, "Expected a string"));
+    return false;
+  }
+  if (/[\r\n\u2028\u2029]/u.test(value)) {
+    diagnostics.push(invalidDiagnostic(path, "Line breaks are not allowed; use line_break"));
+    return false;
+  }
+  if (hasControlCharacter(value)) {
+    diagnostics.push(invalidDiagnostic(path, "Control characters are not allowed"));
+    return false;
+  }
+  return true;
+}
+
+function normalizeEnum<K extends "palettePreset" | "density" | "separator", T extends StatuslineConfig[K]>(
+  value: Record<string, unknown>,
+  field: K,
+  accepted: readonly T[],
+  config: StatuslineConfig,
+  diagnostics: StatuslineConfigDiagnostic[],
 ) {
-	const candidate = value[field];
-	if (candidate === undefined) return;
-	if (typeof candidate !== "string" || !accepted.includes(candidate as T)) {
-		diagnostics.push(
-			invalidDiagnostic(field, `Expected one of: ${accepted.map(String).join(", ")}`),
-		);
-		return;
-	}
-	config[field] = candidate as StatuslineConfig[K];
+  const candidate = value[field];
+  if (candidate === undefined) return;
+  if (typeof candidate !== "string" || !accepted.includes(candidate as T)) {
+    diagnostics.push(invalidDiagnostic(field, `Expected one of: ${accepted.map(String).join(", ")}`));
+    return;
+  }
+  config[field] = candidate as StatuslineConfig[K];
 }
 
 function cloneSegmentPalette(palette: SegmentPalette): SegmentPalette {
-	return Object.fromEntries(
-		Object.entries(palette).map(([name, colors]) => [name, { ...colors }]),
-	) as SegmentPalette;
+  return Object.fromEntries(Object.entries(palette).map(([name, colors]) => [name, { ...colors }])) as SegmentPalette;
 }
 
 function cloneConfig(config: StatuslineConfig): StatuslineConfig {
-	return {
-		...config,
-		palette: cloneSegmentPalette(config.palette),
-		segments: [...config.segments],
-		segmentText: Object.fromEntries(
-			SEGMENT_NAMES.map((name) => [name, { ...config.segmentText[name] }]),
-		) as StatuslineConfig["segmentText"],
-		extensionStatusIcons: { ...config.extensionStatusIcons },
-	};
+  return {
+    ...config,
+    palette: cloneSegmentPalette(config.palette),
+    segments: [...config.segments],
+    segmentText: Object.fromEntries(
+      SEGMENT_NAMES.map((name) => [name, { ...config.segmentText[name] }]),
+    ) as StatuslineConfig["segmentText"],
+    extensionStatusIcons: { ...config.extensionStatusIcons },
+  };
 }
 
 function builtInSettings(
-	settingsPath: string,
-	diagnostics: StatuslineConfigDiagnostic[] = [],
+  settingsPath: string,
+  diagnostics: StatuslineConfigDiagnostic[] = [],
 ): LoadedStatuslineSettings {
-	return {
-		config: createDefaultConfig(),
-		source: "built-in",
-		settingsPath,
-		diagnostics,
-	};
+  return {
+    config: createDefaultConfig(),
+    source: "built-in",
+    settingsPath,
+    diagnostics,
+  };
 }
 
 function hasControlCharacter(value: string): boolean {
-	for (const character of value) {
-		const codePoint = character.codePointAt(0) ?? 0;
-		if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) return true;
-	}
-	return false;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) return true;
+  }
+  return false;
 }
 
 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 isConfigSegmentName(value: string): value is ConfigSegmentName {
-	return value === LINE_BREAK_SEGMENT_NAME || isSegmentName(value);
+  return value === LINE_BREAK_SEGMENT_NAME || isSegmentName(value);
 }
 
 function isPaletteName(value: StatuslineConfig["palettePreset"]): value is PaletteName {
-	return (PALETTE_NAMES as readonly StatuslineConfig["palettePreset"][]).includes(value);
+  return (PALETTE_NAMES as readonly StatuslineConfig["palettePreset"][]).includes(value);
 }
 
 function isSegmentName(value: string): value is SegmentName {
-	return (SEGMENT_NAMES as readonly string[]).includes(value);
+  return (SEGMENT_NAMES as readonly string[]).includes(value);
 }
 
-function blockingDiagnostics(
-	diagnostics: readonly StatuslineConfigDiagnostic[],
-): StatuslineConfigDiagnostic[] {
-	return diagnostics.filter((item) => item.code !== "unknown");
+function blockingDiagnostics(diagnostics: readonly StatuslineConfigDiagnostic[]): StatuslineConfigDiagnostic[] {
+  return diagnostics.filter((item) => item.code !== "unknown");
 }
 
 function unknownDiagnostic(path: string): StatuslineConfigDiagnostic {
-	return diagnostic("warning", "unknown", path, `Unknown setting ${JSON.stringify(path)}`);
+  return diagnostic("warning", "unknown", path, `Unknown setting ${JSON.stringify(path)}`);
 }
 
 function invalidDiagnostic(
-	path: string,
-	message: string,
-	severity: StatuslineConfigDiagnostic["severity"] = "warning",
+  path: string,
+  message: string,
+  severity: StatuslineConfigDiagnostic["severity"] = "warning",
 ): StatuslineConfigDiagnostic {
-	return diagnostic(severity, "invalid", path, message);
+  return diagnostic(severity, "invalid", path, message);
 }
 
 function diagnostic(
-	severity: StatuslineConfigDiagnostic["severity"],
-	code: StatuslineConfigDiagnostic["code"],
-	path: string,
-	message: string,
+  severity: StatuslineConfigDiagnostic["severity"],
+  code: StatuslineConfigDiagnostic["code"],
+  path: string,
+  message: string,
 ): StatuslineConfigDiagnostic {
-	return { severity, code, path, message };
+  return { severity, code, path, message };
 }
 
 function temporarySettingsPath(settingsPath: string): string {
-	return join(dirname(settingsPath), `.${SETTINGS_FILE_NAME}.${randomUUID()}.tmp`);
+  return join(dirname(settingsPath), `.${SETTINGS_FILE_NAME}.${randomUUID()}.tmp`);
 }
 
 function removeTemporaryFile(remove: typeof rmSync, temporaryPath: string) {
-	try {
-		remove(temporaryPath, { force: true });
-	} catch {
-		// Best-effort cleanup must not replace the original operation result.
-	}
+  try {
+    remove(temporaryPath, { force: true });
+  } catch {
+    // Best-effort cleanup must not replace the original operation result.
+  }
 }
 
 function pathExists(path: string): boolean {
-	try {
-		lstatSync(path);
-		return true;
-	} catch {
-		return false;
-	}
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function pathEntryExists(path: string): boolean {
-	try {
-		lstatSync(path);
-		return true;
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-		throw error;
-	}
+  try {
+    lstatSync(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
 }
 
 function formatError(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
+  return error instanceof Error ? error.message : String(error);
 }